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