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