Connors Ready To Go

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