Feature: Josh Morrow

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