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