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

"China has built a massive infrastructure specifically - and solely - to support advanced military capabilities that can deploy to the bases on short notice..."
