Tourette type of market

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