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