Switch from Godep to go vendoring

2016-03-01 01:51:26 +01:00 · 2016-03-01 01:51:26 +01:00 · cd317761c5
commit cd317761c5
parent 6b37713bc0
1504 changed files with 263076 additions and 34441 deletions
--- a/vendor/github.com/willf/bitset/LICENSE
+++ b/vendor/github.com/willf/bitset/LICENSE
@ -0,0 +1,27 @@
+Copyright (c) 2014 Will Fitzgerald. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--- a/vendor/github.com/willf/bitset/Makefile
+++ b/vendor/github.com/willf/bitset/Makefile
@ -0,0 +1,109 @@
+# MAKEFILE
+#
+# @author      Nicola Asuni <nicola@cognitivelogic.com>
+# @link        https://github.com/willf/bitset
+# ------------------------------------------------------------------------------
+
+# List special make targets that are not associated with files
+.PHONY: help all qa test format fmtcheck vet lint coverage docs deps clean nuke
+
+# Use bash as shell (Note: Ubuntu now uses dash which doesn't support PIPESTATUS).
+SHELL=/bin/bash
+
+# Project owner
+OWNER=willf
+
+# Project name
+PROJECT=bitset
+
+# Name of RPM or DEB package
+PKGNAME=${OWNER}-${PROJECT}
+
+# Go lang path. Set if necessary
+# GOPATH=$(shell readlink -f $(shell pwd)/../../../../)
+
+# Current directory
+CURRENTDIR=$(shell pwd)
+
+# --- MAKE TARGETS ---
+
+# Display general help about this command
+help:
+	@echo ""
+	@echo "$(PROJECT) Makefile."
+	@echo "The following commands are available:"
+	@echo ""
+	@echo "    make qa         : Run all the tests"
+	@echo "    make test       : Run the unit tests"
+	@echo ""
+	@echo "    make format     : Format the source code"
+	@echo "    make fmtcheck   : Check if the source code has been formatted"
+	@echo "    make vet        : Check for syntax errors"
+	@echo "    make lint       : Check for style errors"
+	@echo "    make coverage   : Generate the coverage report"
+	@echo ""
+	@echo "    make docs       : Generate source code documentation"
+	@echo ""
+	@echo "    make deps       : Get the dependencies"
+	@echo "    make clean      : Remove any build artifact"
+	@echo "    make nuke       : Deletes any intermediate file"
+	@echo ""
+
+# Alias for help target
+all: help
+
+# Run the unit tests
+test:
+	@mkdir -p target/test
+	@mkdir -p target/report
+	GOPATH=$(GOPATH) go test -covermode=count -coverprofile=target/report/coverage.out -bench=. -race -v ./... | tee >(PATH=$(GOPATH)/bin:$(PATH) go-junit-report > target/test/report.xml); test $${PIPESTATUS[0]} -eq 0
+
+# Format the source code
+format:
+	@find ./ -type f -name "*.go" -exec gofmt -w {} \;
+
+# Check if the source code has been formatted
+fmtcheck:
+	@mkdir -p target
+	@find ./ -type f -name "*.go" -exec gofmt -d {} \; | tee target/format.diff
+	@test ! -s target/format.diff || { echo "ERROR: the source code has not been formatted - please use 'make format' or 'gofmt'"; exit 1; }
+
+# Check for syntax errors
+vet:
+	GOPATH=$(GOPATH) go vet ./...
+
+# Check for style errors
+lint:
+	GOPATH=$(GOPATH) PATH=$(GOPATH)/bin:$(PATH) golint ./...
+
+# Generate the coverage report
+coverage:
+	GOPATH=$(GOPATH) go tool cover -html=target/report/coverage.out -o target/report/coverage.html
+
+# Generate source docs
+docs:
+	@mkdir -p target/docs
+	nohup sh -c 'GOPATH=$(GOPATH) godoc -http=127.0.0.1:6060' > target/godoc_server.log 2>&1 &
+	wget --directory-prefix=target/docs/ --execute robots=off --retry-connrefused --recursive --no-parent --adjust-extension --page-requisites --convert-links http://127.0.0.1:6060/pkg/github.com/${OWNER}/${PROJECT}/ ; kill -9 `lsof -ti :6060`
+	@echo '<html><head><meta http-equiv="refresh" content="0;./127.0.0.1:6060/pkg/github.com/'${OWNER}'/'${PROJECT}'/index.html"/></head><a href="./127.0.0.1:6060/pkg/github.com/'${OWNER}'/'${PROJECT}'/index.html">'${PKGNAME}' Documentation ...</a></html>' > target/docs/index.html
+
+# Alias to run targets: fmtcheck test vet lint coverage
+qa: fmtcheck test vet lint coverage
+
+# --- INSTALL ---
+
+# Get the dependencies
+deps:
+	GOPATH=$(GOPATH) go get ./...
+	GOPATH=$(GOPATH) go get github.com/golang/lint/golint
+	GOPATH=$(GOPATH) go get github.com/jstemmer/go-junit-report
+	GOPATH=$(GOPATH) go get github.com/axw/gocov/gocov
+
+# Remove any build artifact
+clean:
+	GOPATH=$(GOPATH) go clean ./...
+
+# Deletes any intermediate file
+nuke:
+	rm -rf ./target
+	GOPATH=$(GOPATH) go clean -i ./...
--- a/vendor/github.com/willf/bitset/README.md
+++ b/vendor/github.com/willf/bitset/README.md
@ -0,0 +1,65 @@
+# bitset
+
+*Go language library to map between non-negative integers and boolean values*
+
+[![Master Branch](https://img.shields.io/badge/-master:-gray.svg)](https://github.com/willf/bitset/tree/master)
+[![Master Build Status](https://travis-ci.org/willf/bitset.svg?branch=master)](https://travis-ci.org/willf/bitset)
+[![Develop Branch](https://img.shields.io/badge/-develop:-gray.svg)](https://github.com/willf/bitset/tree/develop)
+[![Develop Build Status](https://secure.travis-ci.org/willf/bitset.svg?branch=develop)](https://travis-ci.org/willf/bitset?branch=develop)
+
+
+
+## Description
+
+Package bitset implements bitsets, a mapping between non-negative integers and boolean values.
+It should be more efficient than map[uint] bool.
+
+It provides methods for setting, clearing, flipping, and testing individual integers.
+
+But it also provides set intersection, union, difference, complement, and symmetric operations, as well as tests to check whether any, all, or no bits are set, and querying a bitset's current length and number of postive bits.
+
+BitSets are expanded to the size of the largest set bit; the memory allocation is approximately Max bits, where Max is the largest set bit. BitSets are never shrunk. On creation, a hint can be given for the number of bits that will be used.
+
+Many of the methods, including Set, Clear, and Flip, return a BitSet pointer, which allows for chaining.
+
+### Example use:
+
+    import "bitset"
+    var b BitSet
+    b.Set(10).Set(11)
+    if b.Test(1000) {
+        b.Clear(1000)
+    }
+    for i,e := v.NextSet(0); e; i,e = v.NextSet(i + 1) {
+       frmt.Println("The following bit is set:",i);
+    }
+    if B.Intersection(bitset.New(100).Set(10)).Count() > 1 {
+        fmt.Println("Intersection works.")
+    }
+
+As an alternative to BitSets, one should check out the 'big' package, which provides a (less set-theoretical) view of bitsets.
+
+Discussions golang-nuts Google Group:
+
+* [Revised BitSet](https://groups.google.com/forum/#!topic/golang-nuts/5i3l0CXDiBg)
+* [simple bitset?](https://groups.google.com/d/topic/golang-nuts/7n1VkRTlBf4/discussion)
+
+Godoc documentation is at: https://godoc.org/github.com/willf/bitset
+
+
+## Getting started
+
+This application is written in the go language, please refer to the guides in https://golang.org for getting started.
+
+This project include a Makefile that allows you to test and build the project with simple commands.
+To see all available options:
+```bash
+make help
+```
+
+## Running all tests
+
+Before committing the code, please check if it passes all tests using
+```bash
+make qa
+```
--- a/vendor/github.com/willf/bitset/RELEASE
+++ b/vendor/github.com/willf/bitset/RELEASE
@ -0,0 +1 @@
+1
--- a/vendor/github.com/willf/bitset/VERSION
+++ b/vendor/github.com/willf/bitset/VERSION
@ -0,0 +1 @@
+1.1.0
--- a/vendor/github.com/willf/bitset/bitset.go
+++ b/vendor/github.com/willf/bitset/bitset.go
@ -0,0 +1,650 @@
+/*
+Package bitset implements bitsets, a mapping
+between non-negative integers and boolean values. It should be more
+efficient than map[uint] bool.
+
+It provides methods for setting, clearing, flipping, and testing
+individual integers.
+
+But it also provides set intersection, union, difference,
+complement, and symmetric operations, as well as tests to
+check whether any, all, or no bits are set, and querying a
+bitset's current length and number of postive bits.
+
+BitSets are expanded to the size of the largest set bit; the
+memory allocation is approximately Max bits, where Max is
+the largest set bit. BitSets are never shrunk. On creation,
+a hint can be given for the number of bits that will be used.
+
+Many of the methods, including Set,Clear, and Flip, return
+a BitSet pointer, which allows for chaining.
+
+Example use:
+
+	import "bitset"
+	var b BitSet
+	b.Set(10).Set(11)
+	if b.Test(1000) {
+		b.Clear(1000)
+	}
+	if B.Intersection(bitset.New(100).Set(10)).Count() > 1 {
+		fmt.Println("Intersection works.")
+	}
+
+As an alternative to BitSets, one should check out the 'big' package,
+which provides a (less set-theoretical) view of bitsets.
+
+*/
+package bitset
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/base64"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+)
+
+// the wordSize of a bit set
+const wordSize = uint(64)
+
+// log2WordSize is lg(wordSize)
+const log2WordSize = uint(6)
+
+// A BitSet is a set of bits. The zero value of a BitSet is an empty set of length 0.
+type BitSet struct {
+	length uint
+	set    []uint64
+}
+
+// Error is used to distinguish errors (panics) generated in this package.
+type Error string
+
+// safeSet will fixup b.set to be non-nil and return the field value
+func (b *BitSet) safeSet() []uint64 {
+	if b.set == nil {
+		b.set = make([]uint64, wordsNeeded(0))
+	}
+	return b.set
+}
+
+// From is a constructor used to create a BitSet from an array of integers
+func From(buf []uint64) *BitSet {
+	return &BitSet{uint(len(buf)) * 64, buf}
+}
+
+// Bytes returns the bitset as array of integers
+func (b *BitSet) Bytes() []uint64 {
+	return b.set
+}
+
+// wordsNeeded calculates the number of words needed for i bits
+func wordsNeeded(i uint) int {
+	if i > ((^uint(0)) - wordSize + 1) {
+		return int((^uint(0)) >> log2WordSize)
+	}
+	return int((i + (wordSize - 1)) >> log2WordSize)
+}
+
+// New creates a new BitSet with a hint that length bits will be required
+func New(length uint) *BitSet {
+	return &BitSet{length, make([]uint64, wordsNeeded(length))}
+}
+
+// Cap returns the total possible capicity, or number of bits
+func Cap() uint {
+	return ^uint(0)
+}
+
+// Len returns the length of the BitSet in words
+func (b *BitSet) Len() uint {
+	return b.length
+}
+
+// extendSetMaybe adds additional words to incorporate new bits if needed
+func (b *BitSet) extendSetMaybe(i uint) {
+	if i >= b.length { // if we need more bits, make 'em
+		nsize := wordsNeeded(i + 1)
+		if b.set == nil {
+			b.set = make([]uint64, nsize)
+		} else if len(b.set) < nsize {
+			newset := make([]uint64, nsize)
+			copy(newset, b.set)
+			b.set = newset
+		}
+		b.length = i + 1
+	}
+}
+
+// Test whether bit i is set.
+func (b *BitSet) Test(i uint) bool {
+	if i >= b.length {
+		return false
+	}
+	return b.set[i>>log2WordSize]&(1<<(i&(wordSize-1))) != 0
+}
+
+// Set bit i to 1
+func (b *BitSet) Set(i uint) *BitSet {
+	b.extendSetMaybe(i)
+	b.set[i>>log2WordSize] |= 1 << (i & (wordSize - 1))
+	return b
+}
+
+// Clear bit i to 0
+func (b *BitSet) Clear(i uint) *BitSet {
+	if i >= b.length {
+		return b
+	}
+	b.set[i>>log2WordSize] &^= 1 << (i & (wordSize - 1))
+	return b
+}
+
+// SetTo sets bit i to value
+func (b *BitSet) SetTo(i uint, value bool) *BitSet {
+	if value {
+		return b.Set(i)
+	}
+	return b.Clear(i)
+}
+
+// Flip bit at i
+func (b *BitSet) Flip(i uint) *BitSet {
+	if i >= b.length {
+		return b.Set(i)
+	}
+	b.set[i>>log2WordSize] ^= 1 << (i & (wordSize - 1))
+	return b
+}
+
+// NextSet returns the next bit set from the specified index,
+// including possibly the current index
+// along with an error code (true = valid, false = no set bit found)
+// for i,e := v.NextSet(0); e; i,e = v.NextSet(i + 1) {...}
+func (b *BitSet) NextSet(i uint) (uint, bool) {
+	x := int(i >> log2WordSize)
+	if x >= len(b.set) {
+		return 0, false
+	}
+	w := b.set[x]
+	w = w >> (i & (wordSize - 1))
+	if w != 0 {
+		return i + trailingZeroes64(w), true
+	}
+	x = x + 1
+	for x < len(b.set) {
+		if b.set[x] != 0 {
+			return uint(x)*wordSize + trailingZeroes64(b.set[x]), true
+		}
+		x = x + 1
+
+	}
+	return 0, false
+}
+
+// ClearAll clears the entire BitSet
+func (b *BitSet) ClearAll() *BitSet {
+	if b != nil && b.set != nil {
+		for i := range b.set {
+			b.set[i] = 0
+		}
+	}
+	return b
+}
+
+// wordCount returns the number of words used in a bit set
+func (b *BitSet) wordCount() int {
+	return wordsNeeded(b.length)
+}
+
+// Clone this BitSet
+func (b *BitSet) Clone() *BitSet {
+	c := New(b.length)
+	if b.set != nil { // Clone should not modify current object
+		copy(c.set, b.set)
+	}
+	return c
+}
+
+// Copy into a destination BitSet
+// Returning the size of the destination BitSet
+// like array copy
+func (b *BitSet) Copy(c *BitSet) (count uint) {
+	if c == nil {
+		return
+	}
+	if b.set != nil { // Copy should not modify current object
+		copy(c.set, b.set)
+	}
+	count = c.length
+	if b.length < c.length {
+		count = b.length
+	}
+	return
+}
+
+// Count (number of set bits)
+func (b *BitSet) Count() uint {
+	if b != nil && b.set != nil {
+		return uint(popcntSlice(b.set))
+	}
+	return 0
+}
+
+var deBruijn = [...]byte{
+	0, 1, 56, 2, 57, 49, 28, 3, 61, 58, 42, 50, 38, 29, 17, 4,
+	62, 47, 59, 36, 45, 43, 51, 22, 53, 39, 33, 30, 24, 18, 12, 5,
+	63, 55, 48, 27, 60, 41, 37, 16, 46, 35, 44, 21, 52, 32, 23, 11,
+	54, 26, 40, 15, 34, 20, 31, 10, 25, 14, 19, 9, 13, 8, 7, 6,
+}
+
+func trailingZeroes64(v uint64) uint {
+	return uint(deBruijn[((v&-v)*0x03f79d71b4ca8b09)>>58])
+}
+
+// Equal tests the equvalence of two BitSets.
+// False if they are of different sizes, otherwise true
+// only if all the same bits are set
+func (b *BitSet) Equal(c *BitSet) bool {
+	if c == nil {
+		return false
+	}
+	if b.length != c.length {
+		return false
+	}
+	if b.length == 0 { // if they have both length == 0, then could have nil set
+		return true
+	}
+	// testing for equality shoud not transform the bitset (no call to safeSet)
+
+	for p, v := range b.set {
+		if c.set[p] != v {
+			return false
+		}
+	}
+	return true
+}
+
+func panicIfNull(b *BitSet) {
+	if b == nil {
+		panic(Error("BitSet must not be null"))
+	}
+}
+
+// Difference of base set and other set
+// This is the BitSet equivalent of &^ (and not)
+func (b *BitSet) Difference(compare *BitSet) (result *BitSet) {
+	panicIfNull(b)
+	panicIfNull(compare)
+	result = b.Clone() // clone b (in case b is bigger than compare)
+	l := int(compare.wordCount())
+	if l > int(b.wordCount()) {
+		l = int(b.wordCount())
+	}
+	for i := 0; i < l; i++ {
+		result.set[i] = b.set[i] &^ compare.set[i]
+	}
+	return
+}
+
+// DifferenceCardinality computes the cardinality of the differnce
+func (b *BitSet) DifferenceCardinality(compare *BitSet) uint {
+	panicIfNull(b)
+	panicIfNull(compare)
+	l := int(compare.wordCount())
+	if l > int(b.wordCount()) {
+		l = int(b.wordCount())
+	}
+	cnt := uint64(0)
+	cnt += popcntMaskSlice(b.set[:l], compare.set[:l])
+	cnt += popcntSlice(b.set[l:])
+	return uint(cnt)
+}
+
+// InPlaceDifference computes the difference of base set and other set
+// This is the BitSet equivalent of &^ (and not)
+func (b *BitSet) InPlaceDifference(compare *BitSet) {
+	panicIfNull(b)
+	panicIfNull(compare)
+	l := int(compare.wordCount())
+	if l > int(b.wordCount()) {
+		l = int(b.wordCount())
+	}
+	for i := 0; i < l; i++ {
+		b.set[i] &^= compare.set[i]
+	}
+}
+
+// Convenience function: return two bitsets ordered by
+// increasing length. Note: neither can be nil
+func sortByLength(a *BitSet, b *BitSet) (ap *BitSet, bp *BitSet) {
+	if a.length <= b.length {
+		ap, bp = a, b
+	} else {
+		ap, bp = b, a
+	}
+	return
+}
+
+// Intersection of base set and other set
+// This is the BitSet equivalent of & (and)
+func (b *BitSet) Intersection(compare *BitSet) (result *BitSet) {
+	panicIfNull(b)
+	panicIfNull(compare)
+	b, compare = sortByLength(b, compare)
+	result = New(b.length)
+	for i, word := range b.set {
+		result.set[i] = word & compare.set[i]
+	}
+	return
+}
+
+// IntersectionCardinality computes the cardinality of the union
+func (b *BitSet) IntersectionCardinality(compare *BitSet) uint {
+	panicIfNull(b)
+	panicIfNull(compare)
+	b, compare = sortByLength(b, compare)
+	cnt := popcntAndSlice(b.set, compare.set)
+	return uint(cnt)
+}
+
+// InPlaceIntersection destructively computes the intersection of
+// base set and the compare set.
+// This is the BitSet equivalent of & (and)
+func (b *BitSet) InPlaceIntersection(compare *BitSet) {
+	panicIfNull(b)
+	panicIfNull(compare)
+	l := int(compare.wordCount())
+	if l > int(b.wordCount()) {
+		l = int(b.wordCount())
+	}
+	for i := 0; i < l; i++ {
+		b.set[i] &= compare.set[i]
+	}
+	for i := l; i < len(b.set); i++ {
+		b.set[i] = 0
+	}
+	if compare.length > 0 {
+		b.extendSetMaybe(compare.length - 1)
+	}
+	return
+}
+
+// Union of base set and other set
+// This is the BitSet equivalent of | (or)
+func (b *BitSet) Union(compare *BitSet) (result *BitSet) {
+	panicIfNull(b)
+	panicIfNull(compare)
+	b, compare = sortByLength(b, compare)
+	result = compare.Clone()
+	for i, word := range b.set {
+		result.set[i] = word | compare.set[i]
+	}
+	return
+}
+
+// UnionCardinality computes the cardinality of the uniton of the base set
+// and the compare set.
+func (b *BitSet) UnionCardinality(compare *BitSet) uint {
+	panicIfNull(b)
+	panicIfNull(compare)
+	b, compare = sortByLength(b, compare)
+	cnt := popcntOrSlice(b.set, compare.set)
+	if len(compare.set) > len(b.set) {
+		cnt += popcntSlice(compare.set[len(b.set):])
+	}
+	return uint(cnt)
+}
+
+// InPlaceUnion creates the destructive union of base set and compare set.
+// This is the BitSet equivalent of | (or).
+func (b *BitSet) InPlaceUnion(compare *BitSet) {
+	panicIfNull(b)
+	panicIfNull(compare)
+	l := int(compare.wordCount())
+	if l > int(b.wordCount()) {
+		l = int(b.wordCount())
+	}
+	if compare.length > 0 {
+		b.extendSetMaybe(compare.length - 1)
+	}
+	for i := 0; i < l; i++ {
+		b.set[i] |= compare.set[i]
+	}
+	if len(compare.set) > l {
+		for i := l; i < len(compare.set); i++ {
+			b.set[i] = compare.set[i]
+		}
+	}
+}
+
+// SymmetricDifference of base set and other set
+// This is the BitSet equivalent of ^ (xor)
+func (b *BitSet) SymmetricDifference(compare *BitSet) (result *BitSet) {
+	panicIfNull(b)
+	panicIfNull(compare)
+	b, compare = sortByLength(b, compare)
+	// compare is bigger, so clone it
+	result = compare.Clone()
+	for i, word := range b.set {
+		result.set[i] = word ^ compare.set[i]
+	}
+	return
+}
+
+// SymmetricDifferenceCardinality computes the cardinality of the symmetric difference
+func (b *BitSet) SymmetricDifferenceCardinality(compare *BitSet) uint {
+	panicIfNull(b)
+	panicIfNull(compare)
+	b, compare = sortByLength(b, compare)
+	cnt := popcntXorSlice(b.set, compare.set)
+	if len(compare.set) > len(b.set) {
+		cnt += popcntSlice(compare.set[len(b.set):])
+	}
+	return uint(cnt)
+}
+
+// InPlaceSymmetricDifference creates the destructive SymmetricDifference of base set and other set
+// This is the BitSet equivalent of ^ (xor)
+func (b *BitSet) InPlaceSymmetricDifference(compare *BitSet) {
+	panicIfNull(b)
+	panicIfNull(compare)
+	l := int(compare.wordCount())
+	if l > int(b.wordCount()) {
+		l = int(b.wordCount())
+	}
+	if compare.length > 0 {
+		b.extendSetMaybe(compare.length - 1)
+	}
+	for i := 0; i < l; i++ {
+		b.set[i] ^= compare.set[i]
+	}
+	if len(compare.set) > l {
+		for i := l; i < len(compare.set); i++ {
+			b.set[i] = compare.set[i]
+		}
+	}
+}
+
+// Is the length an exact multiple of word sizes?
+func (b *BitSet) isEven() bool {
+	return b.length%wordSize == 0
+}
+
+// Clean last word by setting unused bits to 0
+func (b *BitSet) cleanLastWord() {
+	if !b.isEven() {
+		// Mask for cleaning last word
+		const allBits uint64 = 0xffffffffffffffff
+		b.set[wordsNeeded(b.length)-1] &= allBits >> (wordSize - b.length%wordSize)
+	}
+}
+
+// Complement computes the (local) complement of a biset (up to length bits)
+func (b *BitSet) Complement() (result *BitSet) {
+	panicIfNull(b)
+	result = New(b.length)
+	for i, word := range b.set {
+		result.set[i] = ^word
+	}
+	result.cleanLastWord()
+	return
+}
+
+// All returns true if all bits are set, false otherwise
+func (b *BitSet) All() bool {
+	panicIfNull(b)
+	return b.Count() == b.length
+}
+
+// None returns true if no bit is set, false otherwise
+func (b *BitSet) None() bool {
+	panicIfNull(b)
+	if b != nil && b.set != nil {
+		for _, word := range b.set {
+			if word > 0 {
+				return false
+			}
+		}
+		return true
+	}
+	return true
+}
+
+// Any returns true if any bit is set, false otherwise
+func (b *BitSet) Any() bool {
+	panicIfNull(b)
+	return !b.None()
+}
+
+// IsSuperSet returns true if this is a superset of the other set
+func (b *BitSet) IsSuperSet(other *BitSet) bool {
+	for i, e := other.NextSet(0); e; i, e = other.NextSet(i + 1) {
+		if !b.Test(i) {
+			return false
+		}
+	}
+	return true
+}
+
+// IsStrictSuperSet returns true if this is a strict superset of the other set
+func (b *BitSet) IsStrictSuperSet(other *BitSet) bool {
+	return b.Count() > other.Count() && b.IsSuperSet(other)
+}
+
+// DumpAsBits dumps a bit set as a string of bits
+func (b *BitSet) DumpAsBits() string {
+	if b.set == nil {
+		return "."
+	}
+	buffer := bytes.NewBufferString("")
+	i := len(b.set) - 1
+	for ; i >= 0; i-- {
+		fmt.Fprintf(buffer, "%064b.", b.set[i])
+	}
+	return string(buffer.Bytes())
+}
+
+// BinaryStorageSize returns the binary storage requirements
+func (b *BitSet) BinaryStorageSize() int {
+	return binary.Size(uint64(0)) + binary.Size(b.set)
+}
+
+// WriteTo writes a BitSet to a stream
+func (b *BitSet) WriteTo(stream io.Writer) (int64, error) {
+	length := uint64(b.length)
+
+	// Write length
+	err := binary.Write(stream, binary.BigEndian, length)
+	if err != nil {
+		return 0, err
+	}
+
+	// Write set
+	err = binary.Write(stream, binary.BigEndian, b.set)
+	return int64(b.BinaryStorageSize()), err
+}
+
+// ReadFrom reads a BitSet from a stream written using WriteTo
+func (b *BitSet) ReadFrom(stream io.Reader) (int64, error) {
+	var length uint64
+
+	// Read length first
+	err := binary.Read(stream, binary.BigEndian, &length)
+	if err != nil {
+		return 0, err
+	}
+	newset := New(uint(length))
+
+	if uint64(newset.length) != length {
+		return 0, errors.New("Unmarshalling error: type mismatch")
+	}
+
+	// Read remaining bytes as set
+	err = binary.Read(stream, binary.BigEndian, newset.set)
+	if err != nil {
+		return 0, err
+	}
+
+	*b = *newset
+	return int64(b.BinaryStorageSize()), nil
+}
+
+// MarshalBinary encodes a BitSet into a binary form and returns the result.
+func (b *BitSet) MarshalBinary() ([]byte, error) {
+	var buf bytes.Buffer
+	writer := bufio.NewWriter(&buf)
+
+	_, err := b.WriteTo(writer)
+	if err != nil {
+		return []byte{}, err
+	}
+
+	err = writer.Flush()
+
+	return buf.Bytes(), err
+}
+
+// UnmarshalBinary decodes the binary form generated by MarshalBinary.
+func (b *BitSet) UnmarshalBinary(data []byte) error {
+	buf := bytes.NewReader(data)
+	reader := bufio.NewReader(buf)
+
+	_, err := b.ReadFrom(reader)
+
+	return err
+}
+
+// MarshalJSON marshals a BitSet as a JSON structure
+func (b *BitSet) MarshalJSON() ([]byte, error) {
+	buffer := bytes.NewBuffer(make([]byte, 0, b.BinaryStorageSize()))
+	_, err := b.WriteTo(buffer)
+	if err != nil {
+		return nil, err
+	}
+
+	// URLEncode all bytes
+	return json.Marshal(base64.URLEncoding.EncodeToString(buffer.Bytes()))
+}
+
+// UnmarshalJSON unmarshals a BitSet from JSON created using MarshalJSON
+func (b *BitSet) UnmarshalJSON(data []byte) error {
+	// Unmarshal as string
+	var s string
+	err := json.Unmarshal(data, &s)
+	if err != nil {
+		return err
+	}
+
+	// URLDecode string
+	buf, err := base64.URLEncoding.DecodeString(s)
+	if err != nil {
+		return err
+	}
+
+	_, err = b.ReadFrom(bytes.NewReader(buf))
+	return err
+}
--- a/vendor/github.com/willf/bitset/bitset_test.go
+++ b/vendor/github.com/willf/bitset/bitset_test.go
@ -0,0 +1,837 @@
+// Copyright 2014 Will Fitzgerald. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file tests bit sets
+
+package bitset
+
+import (
+	"encoding"
+	"encoding/json"
+	"math"
+	"math/rand"
+	"testing"
+)
+
+func TestEmptyBitSet(t *testing.T) {
+	defer func() {
+		if r := recover(); r != nil {
+			t.Error("A zero-length bitset should be fine")
+		}
+	}()
+	b := New(0)
+	if b.Len() != 0 {
+		t.Errorf("Empty set should have capacity 0, not %d", b.Len())
+	}
+}
+
+func TestZeroValueBitSet(t *testing.T) {
+	defer func() {
+		if r := recover(); r != nil {
+			t.Error("A zero-length bitset should be fine")
+		}
+	}()
+	var b BitSet
+	if b.Len() != 0 {
+		t.Errorf("Empty set should have capacity 0, not %d", b.Len())
+	}
+}
+
+func TestBitSetNew(t *testing.T) {
+	v := New(16)
+	if v.Test(0) != false {
+		t.Errorf("Unable to make a bit set and read its 0th value.")
+	}
+}
+
+func TestBitSetHuge(t *testing.T) {
+	v := New(uint(math.MaxUint32))
+	if v.Test(0) != false {
+		t.Errorf("Unable to make a huge bit set and read its 0th value.")
+	}
+}
+
+func TestLen(t *testing.T) {
+	v := New(1000)
+	if v.Len() != 1000 {
+		t.Errorf("Len should be 1000, but is %d.", v.Len())
+	}
+}
+
+func TestBitSetIsClear(t *testing.T) {
+	v := New(1000)
+	for i := uint(0); i < 1000; i++ {
+		if v.Test(i) != false {
+			t.Errorf("Bit %d is set, and it shouldn't be.", i)
+		}
+	}
+}
+
+func TestExendOnBoundary(t *testing.T) {
+	v := New(32)
+	defer func() {
+		if r := recover(); r != nil {
+			t.Error("Border out of index error should not have caused a panic")
+		}
+	}()
+	v.Set(32)
+}
+
+func TestExpand(t *testing.T) {
+	v := New(0)
+	defer func() {
+		if r := recover(); r != nil {
+			t.Error("Expansion should not have caused a panic")
+		}
+	}()
+	for i := uint(0); i < 1000; i++ {
+		v.Set(i)
+	}
+}
+
+func TestBitSetAndGet(t *testing.T) {
+	v := New(1000)
+	v.Set(100)
+	if v.Test(100) != true {
+		t.Errorf("Bit %d is clear, and it shouldn't be.", 100)
+	}
+}
+
+func TestIterate(t *testing.T) {
+	v := New(10000)
+	v.Set(0)
+	v.Set(1)
+	v.Set(2)
+	data := make([]uint, 3)
+	c := 0
+	for i, e := v.NextSet(0); e; i, e = v.NextSet(i + 1) {
+		data[c] = i
+		c++
+	}
+	if data[0] != 0 {
+		t.Errorf("bug 0")
+	}
+	if data[1] != 1 {
+		t.Errorf("bug 1")
+	}
+	if data[2] != 2 {
+		t.Errorf("bug 2")
+	}
+	v.Set(10)
+	v.Set(2000)
+	data = make([]uint, 5)
+	c = 0
+	for i, e := v.NextSet(0); e; i, e = v.NextSet(i + 1) {
+		data[c] = i
+		c++
+	}
+	if data[0] != 0 {
+		t.Errorf("bug 0")
+	}
+	if data[1] != 1 {
+		t.Errorf("bug 1")
+	}
+	if data[2] != 2 {
+		t.Errorf("bug 2")
+	}
+	if data[3] != 10 {
+		t.Errorf("bug 3")
+	}
+	if data[4] != 2000 {
+		t.Errorf("bug 4")
+	}
+
+}
+
+func TestSetTo(t *testing.T) {
+	v := New(1000)
+	v.SetTo(100, true)
+	if v.Test(100) != true {
+		t.Errorf("Bit %d is clear, and it shouldn't be.", 100)
+	}
+	v.SetTo(100, false)
+	if v.Test(100) != false {
+		t.Errorf("Bit %d is set, and it shouldn't be.", 100)
+	}
+}
+
+func TestChain(t *testing.T) {
+	if New(1000).Set(100).Set(99).Clear(99).Test(100) != true {
+		t.Errorf("Bit %d is clear, and it shouldn't be.", 100)
+	}
+}
+
+func TestOutOfBoundsLong(t *testing.T) {
+	v := New(64)
+	defer func() {
+		if r := recover(); r != nil {
+			t.Error("Long distance out of index error should not have caused a panic")
+		}
+	}()
+	v.Set(1000)
+}
+
+func TestOutOfBoundsClose(t *testing.T) {
+	v := New(65)
+	defer func() {
+		if r := recover(); r != nil {
+			t.Error("Local out of index error should not have caused a panic")
+		}
+	}()
+	v.Set(66)
+}
+
+func TestCount(t *testing.T) {
+	tot := uint(64*4 + 11) // just some multi unit64 number
+	v := New(tot)
+	checkLast := true
+	for i := uint(0); i < tot; i++ {
+		sz := uint(v.Count())
+		if sz != i {
+			t.Errorf("Count reported as %d, but it should be %d", sz, i)
+			checkLast = false
+			break
+		}
+		v.Set(i)
+	}
+	if checkLast {
+		sz := uint(v.Count())
+		if sz != tot {
+			t.Errorf("After all bits set, size reported as %d, but it should be %d", sz, tot)
+		}
+	}
+}
+
+// test setting every 3rd bit, just in case something odd is happening
+func TestCount2(t *testing.T) {
+	tot := uint(64*4 + 11) // just some multi unit64 number
+	v := New(tot)
+	for i := uint(0); i < tot; i += 3 {
+		sz := uint(v.Count())
+		if sz != i/3 {
+			t.Errorf("Count reported as %d, but it should be %d", sz, i)
+			break
+		}
+		v.Set(i)
+	}
+}
+
+// nil tests
+func TestNullTest(t *testing.T) {
+	var v *BitSet
+	defer func() {
+		if r := recover(); r == nil {
+			t.Error("Checking bit of null reference should have caused a panic")
+		}
+	}()
+	v.Test(66)
+}
+
+func TestNullSet(t *testing.T) {
+	var v *BitSet
+	defer func() {
+		if r := recover(); r == nil {
+			t.Error("Setting bit of null reference should have caused a panic")
+		}
+	}()
+	v.Set(66)
+}
+
+func TestNullClear(t *testing.T) {
+	var v *BitSet
+	defer func() {
+		if r := recover(); r == nil {
+			t.Error("Clearning bit of null reference should have caused a panic")
+		}
+	}()
+	v.Clear(66)
+}
+
+func TestNullCount(t *testing.T) {
+	var v *BitSet
+	defer func() {
+		if r := recover(); r != nil {
+			t.Error("Counting null reference should not have caused a panic")
+		}
+	}()
+	cnt := v.Count()
+	if cnt != 0 {
+		t.Errorf("Count reported as %d, but it should be 0", cnt)
+	}
+}
+
+func TestPanicDifferenceBNil(t *testing.T) {
+	var b *BitSet
+	var compare = New(10)
+	defer func() {
+		if r := recover(); r == nil {
+			t.Error("Nil First should should have caused a panic")
+		}
+	}()
+	b.Difference(compare)
+}
+
+func TestPanicDifferenceCompareNil(t *testing.T) {
+	var compare *BitSet
+	var b = New(10)
+	defer func() {
+		if r := recover(); r == nil {
+			t.Error("Nil Second should should have caused a panic")
+		}
+	}()
+	b.Difference(compare)
+}
+
+func TestPanicUnionBNil(t *testing.T) {
+	var b *BitSet
+	var compare = New(10)
+	defer func() {
+		if r := recover(); r == nil {
+			t.Error("Nil First should should have caused a panic")
+		}
+	}()
+	b.Union(compare)
+}
+
+func TestPanicUnionCompareNil(t *testing.T) {
+	var compare *BitSet
+	var b = New(10)
+	defer func() {
+		if r := recover(); r == nil {
+			t.Error("Nil Second should should have caused a panic")
+		}
+	}()
+	b.Union(compare)
+}
+
+func TestPanicIntersectionBNil(t *testing.T) {
+	var b *BitSet
+	var compare = New(10)
+	defer func() {
+		if r := recover(); r == nil {
+			t.Error("Nil First should should have caused a panic")
+		}
+	}()
+	b.Intersection(compare)
+}
+
+func TestPanicIntersectionCompareNil(t *testing.T) {
+	var compare *BitSet
+	var b = New(10)
+	defer func() {
+		if r := recover(); r == nil {
+			t.Error("Nil Second should should have caused a panic")
+		}
+	}()
+	b.Intersection(compare)
+}
+
+func TestPanicSymmetricDifferenceBNil(t *testing.T) {
+	var b *BitSet
+	var compare = New(10)
+	defer func() {
+		if r := recover(); r == nil {
+			t.Error("Nil First should should have caused a panic")
+		}
+	}()
+	b.SymmetricDifference(compare)
+}
+
+func TestPanicSymmetricDifferenceCompareNil(t *testing.T) {
+	var compare *BitSet
+	var b = New(10)
+	defer func() {
+		if r := recover(); r == nil {
+			t.Error("Nil Second should should have caused a panic")
+		}
+	}()
+	b.SymmetricDifference(compare)
+}
+
+func TestPanicComplementBNil(t *testing.T) {
+	var b *BitSet
+	defer func() {
+		if r := recover(); r == nil {
+			t.Error("Nil should should have caused a panic")
+		}
+	}()
+	b.Complement()
+}
+
+func TestPanicAnytBNil(t *testing.T) {
+	var b *BitSet
+	defer func() {
+		if r := recover(); r == nil {
+			t.Error("Nil should should have caused a panic")
+		}
+	}()
+	b.Any()
+}
+
+func TestPanicNonetBNil(t *testing.T) {
+	var b *BitSet
+	defer func() {
+		if r := recover(); r == nil {
+			t.Error("Nil should should have caused a panic")
+		}
+	}()
+	b.None()
+}
+
+func TestPanicAlltBNil(t *testing.T) {
+	var b *BitSet
+	defer func() {
+		if r := recover(); r == nil {
+			t.Error("Nil should should have caused a panic")
+		}
+	}()
+	b.All()
+}
+
+func TestEqual(t *testing.T) {
+	a := New(100)
+	b := New(99)
+	c := New(100)
+	if a.Equal(b) {
+		t.Error("Sets of different sizes should be not be equal")
+	}
+	if !a.Equal(c) {
+		t.Error("Two empty sets of the same size should be equal")
+	}
+	a.Set(99)
+	c.Set(0)
+	if a.Equal(c) {
+		t.Error("Two sets with differences should not be equal")
+	}
+	c.Set(99)
+	a.Set(0)
+	if !a.Equal(c) {
+		t.Error("Two sets with the same bits set should be equal")
+	}
+}
+
+func TestUnion(t *testing.T) {
+	a := New(100)
+	b := New(200)
+	for i := uint(1); i < 100; i += 2 {
+		a.Set(i)
+		b.Set(i - 1)
+	}
+	for i := uint(100); i < 200; i++ {
+		b.Set(i)
+	}
+	if a.UnionCardinality(b) != 200 {
+		t.Errorf("Union should have 200 bits set, but had %d", a.UnionCardinality(b))
+	}
+	if a.UnionCardinality(b) != b.UnionCardinality(a) {
+		t.Errorf("Union should be symmetric")
+	}
+
+	c := a.Union(b)
+	d := b.Union(a)
+	if c.Count() != 200 {
+		t.Errorf("Union should have 200 bits set, but had %d", c.Count())
+	}
+	if !c.Equal(d) {
+		t.Errorf("Union should be symmetric")
+	}
+}
+
+func TestInPlaceUnion(t *testing.T) {
+	a := New(100)
+	b := New(200)
+	for i := uint(1); i < 100; i += 2 {
+		a.Set(i)
+		b.Set(i - 1)
+	}
+	for i := uint(100); i < 200; i++ {
+		b.Set(i)
+	}
+	c := a.Clone()
+	c.InPlaceUnion(b)
+	d := b.Clone()
+	d.InPlaceUnion(a)
+	if c.Count() != 200 {
+		t.Errorf("Union should have 200 bits set, but had %d", c.Count())
+	}
+	if d.Count() != 200 {
+		t.Errorf("Union should have 200 bits set, but had %d", d.Count())
+	}
+	if !c.Equal(d) {
+		t.Errorf("Union should be symmetric")
+	}
+}
+
+func TestIntersection(t *testing.T) {
+	a := New(100)
+	b := New(200)
+	for i := uint(1); i < 100; i += 2 {
+		a.Set(i)
+		b.Set(i - 1).Set(i)
+	}
+	for i := uint(100); i < 200; i++ {
+		b.Set(i)
+	}
+	if a.IntersectionCardinality(b) != 50 {
+		t.Errorf("Intersection should have 50 bits set, but had %d", a.IntersectionCardinality(b))
+	}
+	if a.IntersectionCardinality(b) != b.IntersectionCardinality(a) {
+		t.Errorf("Intersection should be symmetric")
+	}
+	c := a.Intersection(b)
+	d := b.Intersection(a)
+	if c.Count() != 50 {
+		t.Errorf("Intersection should have 50 bits set, but had %d", c.Count())
+	}
+	if !c.Equal(d) {
+		t.Errorf("Intersection should be symmetric")
+	}
+}
+
+func TestInplaceIntersection(t *testing.T) {
+	a := New(100)
+	b := New(200)
+	for i := uint(1); i < 100; i += 2 {
+		a.Set(i)
+		b.Set(i - 1).Set(i)
+	}
+	for i := uint(100); i < 200; i++ {
+		b.Set(i)
+	}
+	c := a.Clone()
+	c.InPlaceIntersection(b)
+	d := b.Clone()
+	d.InPlaceIntersection(a)
+	if c.Count() != 50 {
+		t.Errorf("Intersection should have 50 bits set, but had %d", c.Count())
+	}
+	if d.Count() != 50 {
+		t.Errorf("Intersection should have 50 bits set, but had %d", d.Count())
+	}
+	if !c.Equal(d) {
+		t.Errorf("Intersection should be symmetric")
+	}
+}
+
+func TestDifference(t *testing.T) {
+	a := New(100)
+	b := New(200)
+	for i := uint(1); i < 100; i += 2 {
+		a.Set(i)
+		b.Set(i - 1)
+	}
+	for i := uint(100); i < 200; i++ {
+		b.Set(i)
+	}
+	if a.DifferenceCardinality(b) != 50 {
+		t.Errorf("a-b Difference should have 50 bits set, but had %d", a.DifferenceCardinality(b))
+	}
+	if b.DifferenceCardinality(a) != 150 {
+		t.Errorf("b-a Difference should have 150 bits set, but had %d", b.DifferenceCardinality(a))
+	}
+
+	c := a.Difference(b)
+	d := b.Difference(a)
+	if c.Count() != 50 {
+		t.Errorf("a-b Difference should have 50 bits set, but had %d", c.Count())
+	}
+	if d.Count() != 150 {
+		t.Errorf("b-a Difference should have 150 bits set, but had %d", d.Count())
+	}
+	if c.Equal(d) {
+		t.Errorf("Difference, here, should not be symmetric")
+	}
+}
+
+func TestInPlaceDifference(t *testing.T) {
+	a := New(100)
+	b := New(200)
+	for i := uint(1); i < 100; i += 2 {
+		a.Set(i)
+		b.Set(i - 1)
+	}
+	for i := uint(100); i < 200; i++ {
+		b.Set(i)
+	}
+	c := a.Clone()
+	c.InPlaceDifference(b)
+	d := b.Clone()
+	d.InPlaceDifference(a)
+	if c.Count() != 50 {
+		t.Errorf("a-b Difference should have 50 bits set, but had %d", c.Count())
+	}
+	if d.Count() != 150 {
+		t.Errorf("b-a Difference should have 150 bits set, but had %d", d.Count())
+	}
+	if c.Equal(d) {
+		t.Errorf("Difference, here, should not be symmetric")
+	}
+}
+
+func TestSymmetricDifference(t *testing.T) {
+	a := New(100)
+	b := New(200)
+	for i := uint(1); i < 100; i += 2 {
+		a.Set(i)            // 01010101010 ... 0000000
+		b.Set(i - 1).Set(i) // 11111111111111111000000
+	}
+	for i := uint(100); i < 200; i++ {
+		b.Set(i)
+	}
+	if a.SymmetricDifferenceCardinality(b) != 150 {
+		t.Errorf("a^b Difference should have 150 bits set, but had %d", a.SymmetricDifferenceCardinality(b))
+	}
+	if b.SymmetricDifferenceCardinality(a) != 150 {
+		t.Errorf("b^a Difference should have 150 bits set, but had %d", b.SymmetricDifferenceCardinality(a))
+	}
+
+	c := a.SymmetricDifference(b)
+	d := b.SymmetricDifference(a)
+	if c.Count() != 150 {
+		t.Errorf("a^b Difference should have 150 bits set, but had %d", c.Count())
+	}
+	if d.Count() != 150 {
+		t.Errorf("b^a Difference should have 150 bits set, but had %d", d.Count())
+	}
+	if !c.Equal(d) {
+		t.Errorf("SymmetricDifference should be symmetric")
+	}
+}
+
+func TestInPlaceSymmetricDifference(t *testing.T) {
+	a := New(100)
+	b := New(200)
+	for i := uint(1); i < 100; i += 2 {
+		a.Set(i)            // 01010101010 ... 0000000
+		b.Set(i - 1).Set(i) // 11111111111111111000000
+	}
+	for i := uint(100); i < 200; i++ {
+		b.Set(i)
+	}
+	c := a.Clone()
+	c.InPlaceSymmetricDifference(b)
+	d := b.Clone()
+	d.InPlaceSymmetricDifference(a)
+	if c.Count() != 150 {
+		t.Errorf("a^b Difference should have 150 bits set, but had %d", c.Count())
+	}
+	if d.Count() != 150 {
+		t.Errorf("b^a Difference should have 150 bits set, but had %d", d.Count())
+	}
+	if !c.Equal(d) {
+		t.Errorf("SymmetricDifference should be symmetric")
+	}
+}
+
+func TestComplement(t *testing.T) {
+	a := New(50)
+	b := a.Complement()
+	if b.Count() != 50 {
+		t.Errorf("Complement failed, size should be 50, but was %d", b.Count())
+	}
+	a = New(50)
+	a.Set(10).Set(20).Set(42)
+	b = a.Complement()
+	if b.Count() != 47 {
+		t.Errorf("Complement failed, size should be 47, but was %d", b.Count())
+	}
+}
+
+func TestIsSuperSet(t *testing.T) {
+	a := New(500)
+	b := New(300)
+	c := New(200)
+
+	// Setup bitsets
+	// a and b overlap
+	// only c is (strict) super set
+	for i := uint(0); i < 100; i++ {
+		a.Set(i)
+	}
+	for i := uint(50); i < 150; i++ {
+		b.Set(i)
+	}
+	for i := uint(0); i < 200; i++ {
+		c.Set(i)
+	}
+
+	if a.IsSuperSet(b) == true {
+		t.Errorf("IsSuperSet fails")
+	}
+	if a.IsSuperSet(c) == true {
+		t.Errorf("IsSuperSet fails")
+	}
+	if b.IsSuperSet(a) == true {
+		t.Errorf("IsSuperSet fails")
+	}
+	if b.IsSuperSet(c) == true {
+		t.Errorf("IsSuperSet fails")
+	}
+	if c.IsSuperSet(a) != true {
+		t.Errorf("IsSuperSet fails")
+	}
+	if c.IsSuperSet(b) != true {
+		t.Errorf("IsSuperSet fails")
+	}
+
+	if a.IsStrictSuperSet(b) == true {
+		t.Errorf("IsStrictSuperSet fails")
+	}
+	if a.IsStrictSuperSet(c) == true {
+		t.Errorf("IsStrictSuperSet fails")
+	}
+	if b.IsStrictSuperSet(a) == true {
+		t.Errorf("IsStrictSuperSet fails")
+	}
+	if b.IsStrictSuperSet(c) == true {
+		t.Errorf("IsStrictSuperSet fails")
+	}
+	if c.IsStrictSuperSet(a) != true {
+		t.Errorf("IsStrictSuperSet fails")
+	}
+	if c.IsStrictSuperSet(b) != true {
+		t.Errorf("IsStrictSuperSet fails")
+	}
+}
+
+func TestDumpAsBits(t *testing.T) {
+	a := New(10).Set(10)
+	astr := "0000000000000000000000000000000000000000000000000000010000000000."
+	if a.DumpAsBits() != astr {
+		t.Errorf("DumpAsBits failed, output should be \"%s\" but was \"%s\"", astr, a.DumpAsBits())
+	}
+	var b BitSet // zero value (b.set == nil)
+	bstr := "."
+	if b.DumpAsBits() != bstr {
+		t.Errorf("DumpAsBits failed, output should be \"%s\" but was \"%s\"", bstr, b.DumpAsBits())
+	}
+}
+
+func TestMarshalUnmarshalBinary(t *testing.T) {
+	a := New(1010).Set(10).Set(1001)
+	b := new(BitSet)
+
+	copyBinary(t, a, b)
+
+	// BitSets must be equal after marshalling and unmarshalling
+	if !a.Equal(b) {
+		t.Error("Bitsets are not equal:\n\t", a.DumpAsBits(), "\n\t", b.DumpAsBits())
+		return
+	}
+}
+
+func copyBinary(t *testing.T, from encoding.BinaryMarshaler, to encoding.BinaryUnmarshaler) {
+	data, err := from.MarshalBinary()
+	if err != nil {
+		t.Errorf(err.Error())
+		return
+	}
+
+	err = to.UnmarshalBinary(data)
+	if err != nil {
+		t.Errorf(err.Error())
+		return
+	}
+}
+
+func TestMarshalUnmarshalJSON(t *testing.T) {
+	a := New(1010).Set(10).Set(1001)
+	data, err := json.Marshal(a)
+	if err != nil {
+		t.Errorf(err.Error())
+		return
+	}
+
+	b := new(BitSet)
+	err = json.Unmarshal(data, b)
+	if err != nil {
+		t.Errorf(err.Error())
+		return
+	}
+
+	// Bitsets must be equal after marshalling and unmarshalling
+	if !a.Equal(b) {
+		t.Error("Bitsets are not equal:\n\t", a.DumpAsBits(), "\n\t", b.DumpAsBits())
+		return
+	}
+}
+
+// BENCHMARKS
+
+func BenchmarkSet(b *testing.B) {
+	b.StopTimer()
+	r := rand.New(rand.NewSource(0))
+	sz := 100000
+	s := New(uint(sz))
+	b.StartTimer()
+	for i := 0; i < b.N; i++ {
+		s.Set(uint(r.Int31n(int32(sz))))
+	}
+}
+
+func BenchmarkGetTest(b *testing.B) {
+	b.StopTimer()
+	r := rand.New(rand.NewSource(0))
+	sz := 100000
+	s := New(uint(sz))
+	b.StartTimer()
+	for i := 0; i < b.N; i++ {
+		s.Test(uint(r.Int31n(int32(sz))))
+	}
+}
+
+func BenchmarkSetExpand(b *testing.B) {
+	b.StopTimer()
+	sz := uint(100000)
+	b.StartTimer()
+	for i := 0; i < b.N; i++ {
+		var s BitSet
+		s.Set(sz)
+	}
+}
+
+// go test -bench=Count
+func BenchmarkCount(b *testing.B) {
+	b.StopTimer()
+	s := New(100000)
+	for i := 0; i < 100000; i += 100 {
+		s.Set(uint(i))
+	}
+	b.StartTimer()
+	for i := 0; i < b.N; i++ {
+		s.Count()
+	}
+}
+
+// go test -bench=Iterate
+func BenchmarkIterate(b *testing.B) {
+	b.StopTimer()
+	s := New(10000)
+	for i := 0; i < 10000; i += 3 {
+		s.Set(uint(i))
+	}
+	b.StartTimer()
+	for j := 0; j < b.N; j++ {
+		c := uint(0)
+		for i, e := s.NextSet(0); e; i, e = s.NextSet(i + 1) {
+			c++
+		}
+	}
+}
+
+// go test -bench=SparseIterate
+func BenchmarkSparseIterate(b *testing.B) {
+	b.StopTimer()
+	s := New(100000)
+	for i := 0; i < 100000; i += 30 {
+		s.Set(uint(i))
+	}
+	b.StartTimer()
+	for j := 0; j < b.N; j++ {
+		c := uint(0)
+		for i, e := s.NextSet(0); e; i, e = s.NextSet(i + 1) {
+			c++
+		}
+	}
+}
--- a/vendor/github.com/willf/bitset/popcnt.go
+++ b/vendor/github.com/willf/bitset/popcnt.go
@ -0,0 +1,53 @@
+package bitset
+
+// bit population count, take from
+// https://code.google.com/p/go/issues/detail?id=4988#c11
+// credit: https://code.google.com/u/arnehormann/
+func popcount(x uint64) (n uint64) {
+	x -= (x >> 1) & 0x5555555555555555
+	x = (x>>2)&0x3333333333333333 + x&0x3333333333333333
+	x += x >> 4
+	x &= 0x0f0f0f0f0f0f0f0f
+	x *= 0x0101010101010101
+	return x >> 56
+}
+
+func popcntSliceGo(s []uint64) uint64 {
+	cnt := uint64(0)
+	for _, x := range s {
+		cnt += popcount(x)
+	}
+	return cnt
+}
+
+func popcntMaskSliceGo(s, m []uint64) uint64 {
+	cnt := uint64(0)
+	for i := range s {
+		cnt += popcount(s[i] &^ m[i])
+	}
+	return cnt
+}
+
+func popcntAndSliceGo(s, m []uint64) uint64 {
+	cnt := uint64(0)
+	for i := range s {
+		cnt += popcount(s[i] & m[i])
+	}
+	return cnt
+}
+
+func popcntOrSliceGo(s, m []uint64) uint64 {
+	cnt := uint64(0)
+	for i := range s {
+		cnt += popcount(s[i] | m[i])
+	}
+	return cnt
+}
+
+func popcntXorSliceGo(s, m []uint64) uint64 {
+	cnt := uint64(0)
+	for i := range s {
+		cnt += popcount(s[i] ^ m[i])
+	}
+	return cnt
+}
--- a/vendor/github.com/willf/bitset/popcnt_amd64.go
+++ b/vendor/github.com/willf/bitset/popcnt_amd64.go
@ -0,0 +1,67 @@
+// +build amd64,!appengine
+
+package bitset
+
+// *** the following functions are defined in popcnt_amd64.s
+
+//go:noescape
+
+func hasAsm() bool
+
+// useAsm is a flag used to select the GO or ASM implementation of the popcnt function
+var useAsm = hasAsm()
+
+//go:noescape
+
+func popcntSliceAsm(s []uint64) uint64
+
+//go:noescape
+
+func popcntMaskSliceAsm(s, m []uint64) uint64
+
+//go:noescape
+
+func popcntAndSliceAsm(s, m []uint64) uint64
+
+//go:noescape
+
+func popcntOrSliceAsm(s, m []uint64) uint64
+
+//go:noescape
+
+func popcntXorSliceAsm(s, m []uint64) uint64
+
+func popcntSlice(s []uint64) uint64 {
+	if useAsm {
+		return popcntSliceAsm(s)
+	}
+	return popcntSliceGo(s)
+}
+
+func popcntMaskSlice(s, m []uint64) uint64 {
+	if useAsm {
+		return popcntMaskSliceAsm(s, m)
+	}
+	return popcntMaskSliceGo(s, m)
+}
+
+func popcntAndSlice(s, m []uint64) uint64 {
+	if useAsm {
+		return popcntAndSliceAsm(s, m)
+	}
+	return popcntAndSliceGo(s, m)
+}
+
+func popcntOrSlice(s, m []uint64) uint64 {
+	if useAsm {
+		return popcntOrSliceAsm(s, m)
+	}
+	return popcntOrSliceGo(s, m)
+}
+
+func popcntXorSlice(s, m []uint64) uint64 {
+	if useAsm {
+		return popcntXorSliceAsm(s, m)
+	}
+	return popcntXorSliceGo(s, m)
+}
--- a/vendor/github.com/willf/bitset/popcnt_amd64.s
+++ b/vendor/github.com/willf/bitset/popcnt_amd64.s
@ -0,0 +1,103 @@
+// +build amd64,!appengine
+
+TEXT ·hasAsm(SB),4,$0-1
+MOVQ $1, AX
+CPUID
+SHRQ $23, CX
+ANDQ $1, CX
+MOVB CX, ret+0(FP)
+RET
+
+#define POPCNTQ_DX_DX BYTE $0xf3; BYTE $0x48; BYTE $0x0f; BYTE $0xb8; BYTE $0xd2
+
+TEXT ·popcntSliceAsm(SB),4,$0-32
+XORQ	AX, AX
+MOVQ	s+0(FP), SI
+MOVQ	s_len+8(FP), CX
+TESTQ	CX, CX
+JZ		popcntSliceEnd
+popcntSliceLoop:
+BYTE $0xf3; BYTE $0x48; BYTE $0x0f; BYTE $0xb8; BYTE $0x16 // POPCNTQ (SI), DX
+ADDQ	DX, AX
+ADDQ	$8, SI
+LOOP	popcntSliceLoop
+popcntSliceEnd:
+MOVQ	AX, ret+24(FP)
+RET
+
+TEXT ·popcntMaskSliceAsm(SB),4,$0-56
+XORQ	AX, AX
+MOVQ	s+0(FP), SI
+MOVQ	s_len+8(FP), CX
+TESTQ	CX, CX
+JZ		popcntMaskSliceEnd
+MOVQ	m+24(FP), DI
+popcntMaskSliceLoop:
+MOVQ	(DI), DX
+NOTQ	DX
+ANDQ	(SI), DX
+POPCNTQ_DX_DX
+ADDQ	DX, AX
+ADDQ	$8, SI
+ADDQ	$8, DI
+LOOP	popcntMaskSliceLoop
+popcntMaskSliceEnd:
+MOVQ	AX, ret+48(FP)
+RET
+
+TEXT ·popcntAndSliceAsm(SB),4,$0-56
+XORQ	AX, AX
+MOVQ	s+0(FP), SI
+MOVQ	s_len+8(FP), CX
+TESTQ	CX, CX
+JZ		popcntAndSliceEnd
+MOVQ	m+24(FP), DI
+popcntAndSliceLoop:
+MOVQ	(DI), DX
+ANDQ	(SI), DX
+POPCNTQ_DX_DX
+ADDQ	DX, AX
+ADDQ	$8, SI
+ADDQ	$8, DI
+LOOP	popcntAndSliceLoop
+popcntAndSliceEnd:
+MOVQ	AX, ret+48(FP)
+RET
+
+TEXT ·popcntOrSliceAsm(SB),4,$0-56
+XORQ	AX, AX
+MOVQ	s+0(FP), SI
+MOVQ	s_len+8(FP), CX
+TESTQ	CX, CX
+JZ		popcntOrSliceEnd
+MOVQ	m+24(FP), DI
+popcntOrSliceLoop:
+MOVQ	(DI), DX
+ORQ		(SI), DX
+POPCNTQ_DX_DX
+ADDQ	DX, AX
+ADDQ	$8, SI
+ADDQ	$8, DI
+LOOP	popcntOrSliceLoop
+popcntOrSliceEnd:
+MOVQ	AX, ret+48(FP)
+RET
+
+TEXT ·popcntXorSliceAsm(SB),4,$0-56
+XORQ	AX, AX
+MOVQ	s+0(FP), SI
+MOVQ	s_len+8(FP), CX
+TESTQ	CX, CX
+JZ		popcntXorSliceEnd
+MOVQ	m+24(FP), DI
+popcntXorSliceLoop:
+MOVQ	(DI), DX
+XORQ	(SI), DX
+POPCNTQ_DX_DX
+ADDQ	DX, AX
+ADDQ	$8, SI
+ADDQ	$8, DI
+LOOP	popcntXorSliceLoop
+popcntXorSliceEnd:
+MOVQ	AX, ret+48(FP)
+RET
--- a/vendor/github.com/willf/bitset/popcnt_generic.go
+++ b/vendor/github.com/willf/bitset/popcnt_generic.go
@ -0,0 +1,23 @@
+// +build !amd64 appengine
+
+package bitset
+
+func popcntSlice(s []uint64) uint64 {
+	return popcntSliceGo(s)
+}
+
+func popcntMaskSlice(s, m []uint64) uint64 {
+	return popcntMaskSliceGo(s, m)
+}
+
+func popcntAndSlice(s, m []uint64) uint64 {
+	return popcntAndSliceGo(s, m)
+}
+
+func popcntOrSlice(s, m []uint64) uint64 {
+	return popcntOrSliceGo(s, m)
+}
+
+func popcntXorSlice(s, m []uint64) uint64 {
+	return popcntXorSliceGo(s, m)
+}
--- a/vendor/github.com/willf/bitset/popcnt_test.go
+++ b/vendor/github.com/willf/bitset/popcnt_test.go
@ -0,0 +1,58 @@
+// +build amd64,!appengine
+
+// This file tests the popcnt funtions
+
+package bitset
+
+import (
+	"testing"
+)
+
+func TestPopcntSlice(t *testing.T) {
+	s := []uint64{2, 3, 5, 7, 11, 13, 17, 19, 23, 29}
+	resGo := popcntSliceGo(s)
+	resAsm := popcntSliceAsm(s)
+	if resGo != resAsm {
+		t.Errorf("The implementations are different: GO %d != ASM %d", resGo, resAsm)
+	}
+}
+
+func TestPopcntMaskSlice(t *testing.T) {
+	s := []uint64{2, 3, 5, 7, 11, 13, 17, 19, 23, 29}
+	m := []uint64{31, 37, 41, 43, 47, 53, 59, 61, 67, 71}
+	resGo := popcntMaskSliceGo(s, m)
+	resAsm := popcntMaskSliceAsm(s, m)
+	if resGo != resAsm {
+		t.Errorf("The implementations are different: GO %d != ASM %d", resGo, resAsm)
+	}
+}
+
+func TestPopcntAndSlice(t *testing.T) {
+	s := []uint64{2, 3, 5, 7, 11, 13, 17, 19, 23, 29}
+	m := []uint64{31, 37, 41, 43, 47, 53, 59, 61, 67, 71}
+	resGo := popcntAndSliceGo(s, m)
+	resAsm := popcntAndSliceAsm(s, m)
+	if resGo != resAsm {
+		t.Errorf("The implementations are different: GO %d != ASM %d", resGo, resAsm)
+	}
+}
+
+func TestPopcntOrSlice(t *testing.T) {
+	s := []uint64{2, 3, 5, 7, 11, 13, 17, 19, 23, 29}
+	m := []uint64{31, 37, 41, 43, 47, 53, 59, 61, 67, 71}
+	resGo := popcntOrSliceGo(s, m)
+	resAsm := popcntOrSliceAsm(s, m)
+	if resGo != resAsm {
+		t.Errorf("The implementations are different: GO %d != ASM %d", resGo, resAsm)
+	}
+}
+
+func TestPopcntXorSlice(t *testing.T) {
+	s := []uint64{2, 3, 5, 7, 11, 13, 17, 19, 23, 29}
+	m := []uint64{31, 37, 41, 43, 47, 53, 59, 61, 67, 71}
+	resGo := popcntXorSliceGo(s, m)
+	resAsm := popcntXorSliceAsm(s, m)
+	if resGo != resAsm {
+		t.Errorf("The implementations are different: GO %d != ASM %d", resGo, resAsm)
+	}
+}