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