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