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