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