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