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