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

"Republicans should face tough questions from the left, but they shouldn’t help leftists pretending to be neutral journalists keep lying to the public about their biases..." 
