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