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