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