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