|
Equipment Store
Welcome to Go-Gear, part of the Go Travel Sites! We are proud to offer a full range of outdoor recreation products in association with our partner, Backcountry.com. Click on any category below to browse hundreds of quality products for sale online.
| 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 |
|
