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