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