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