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