|
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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 |
|
