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