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