All horses can develop problems, but some are easier to investigate than others.
{"content":"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"}