vendorify
diff --git a/go/vendor/vbom.ml/util/LICENSE b/go/vendor/vbom.ml/util/LICENSE
new file mode 100644
index 0000000..5c695fb
--- /dev/null
+++ b/go/vendor/vbom.ml/util/LICENSE
@@ -0,0 +1,17 @@
+The MIT License (MIT)
+Copyright (c) 2015 Frits van Bommel
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/go/vendor/vbom.ml/util/sortorder/README.md b/go/vendor/vbom.ml/util/sortorder/README.md
new file mode 100644
index 0000000..ed8da0e
--- /dev/null
+++ b/go/vendor/vbom.ml/util/sortorder/README.md
@@ -0,0 +1,5 @@
+## sortorder [](https://godoc.org/vbom.ml/util/sortorder)
+
+ import "vbom.ml/util/sortorder"
+
+Sort orders and comparison functions.
diff --git a/go/vendor/vbom.ml/util/sortorder/doc.go b/go/vendor/vbom.ml/util/sortorder/doc.go
new file mode 100644
index 0000000..61b37a9
--- /dev/null
+++ b/go/vendor/vbom.ml/util/sortorder/doc.go
@@ -0,0 +1,5 @@
+// Package sortorder implements sort orders and comparison functions.
+//
+// Currently, it only implements so-called "natural order", where integers
+// embedded in strings are compared by value.
+package sortorder // import "vbom.ml/util/sortorder"
diff --git a/go/vendor/vbom.ml/util/sortorder/natsort.go b/go/vendor/vbom.ml/util/sortorder/natsort.go
new file mode 100644
index 0000000..66a52c7
--- /dev/null
+++ b/go/vendor/vbom.ml/util/sortorder/natsort.go
@@ -0,0 +1,76 @@
+package sortorder
+
+// Natural implements sort.Interface to sort strings in natural order. This
+// means that e.g. "abc2" < "abc12".
+//
+// Non-digit sequences and numbers are compared separately. The former are
+// compared bytewise, while the latter are compared numerically (except that
+// the number of leading zeros is used as a tie-breaker, so e.g. "2" < "02")
+//
+// Limitation: only ASCII digits (0-9) are considered.
+type Natural []string
+
+func (n Natural) Len() int { return len(n) }
+func (n Natural) Swap(i, j int) { n[i], n[j] = n[j], n[i] }
+func (n Natural) Less(i, j int) bool { return NaturalLess(n[i], n[j]) }
+
+func isdigit(b byte) bool { return '0' <= b && b <= '9' }
+
+// NaturalLess compares two strings using natural ordering. This means that e.g.
+// "abc2" < "abc12".
+//
+// Non-digit sequences and numbers are compared separately. The former are
+// compared bytewise, while the latter are compared numerically (except that
+// the number of leading zeros is used as a tie-breaker, so e.g. "2" < "02")
+//
+// Limitation: only ASCII digits (0-9) are considered.
+func NaturalLess(str1, str2 string) bool {
+ idx1, idx2 := 0, 0
+ for idx1 < len(str1) && idx2 < len(str2) {
+ c1, c2 := str1[idx1], str2[idx2]
+ dig1, dig2 := isdigit(c1), isdigit(c2)
+ switch {
+ case dig1 != dig2: // Digits before other characters.
+ return dig1 // True if LHS is a digit, false if the RHS is one.
+ case !dig1: // && !dig2, because dig1 == dig2
+ // UTF-8 compares bytewise-lexicographically, no need to decode
+ // codepoints.
+ if c1 != c2 {
+ return c1 < c2
+ }
+ idx1++
+ idx2++
+ default: // Digits
+ // Eat zeros.
+ for ; idx1 < len(str1) && str1[idx1] == '0'; idx1++ {
+ }
+ for ; idx2 < len(str2) && str2[idx2] == '0'; idx2++ {
+ }
+ // Eat all digits.
+ nonZero1, nonZero2 := idx1, idx2
+ for ; idx1 < len(str1) && isdigit(str1[idx1]); idx1++ {
+ }
+ for ; idx2 < len(str2) && isdigit(str2[idx2]); idx2++ {
+ }
+ // If lengths of numbers with non-zero prefix differ, the shorter
+ // one is less.
+ if len1, len2 := idx1-nonZero1, idx2-nonZero2; len1 != len2 {
+ return len1 < len2
+ }
+ // If they're equal, string comparison is correct.
+ if nr1, nr2 := str1[nonZero1:idx1], str2[nonZero2:idx2]; nr1 != nr2 {
+ return nr1 < nr2
+ }
+ // Otherwise, the one with less zeros is less.
+ // Because everything up to the number is equal, comparing the index
+ // after the zeros is sufficient.
+ if nonZero1 != nonZero2 {
+ return nonZero1 < nonZero2
+ }
+ }
+ // They're identical so far, so continue comparing.
+ }
+ // So far they are identical. At least one is ended. If the other continues,
+ // it sorts last.
+ return len(str1) < len(str2)
+}