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