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

"We will have an opportunity to short these markets before year-end, just not yet (except for maybe Treasuries, which can be shorted already)."
