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