[Vendor] Update directly used dependencys (#15593)

* update github.com/blevesearch/bleve v2.0.2 -> v2.0.3

* github.com/denisenkom/go-mssqldb v0.9.0 -> v0.10.0

* github.com/editorconfig/editorconfig-core-go v2.4.1 -> v2.4.2

* github.com/go-chi/cors v1.1.1 -> v1.2.0

* github.com/go-git/go-billy v5.0.0 -> v5.1.0

* github.com/go-git/go-git v5.2.0 -> v5.3.0

* github.com/go-ldap/ldap v3.2.4 -> v3.3.0

* github.com/go-redis/redis v8.6.0 -> v8.8.2

* github.com/go-sql-driver/mysql v1.5.0 -> v1.6.0

* github.com/go-swagger/go-swagger v0.26.1 -> v0.27.0

* github.com/lib/pq v1.9.0 -> v1.10.1

* github.com/mattn/go-sqlite3 v1.14.6 -> v1.14.7

* github.com/go-testfixtures/testfixtures v3.5.0 -> v3.6.0

* github.com/issue9/identicon v1.0.1 -> v1.2.0

* github.com/klauspost/compress v1.11.8 -> v1.12.1

* github.com/mgechev/revive v1.0.3 -> v1.0.6

* github.com/microcosm-cc/bluemonday v1.0.7 -> v1.0.8

* github.com/niklasfasching/go-org v1.4.0 -> v1.5.0

* github.com/olivere/elastic v7.0.22 -> v7.0.24

* github.com/pelletier/go-toml v1.8.1 -> v1.9.0

* github.com/prometheus/client_golang v1.9.0 -> v1.10.0

* github.com/xanzy/go-gitlab v0.44.0 -> v0.48.0

* github.com/yuin/goldmark v1.3.3 -> v1.3.5

* github.com/6543/go-version v1.2.4 -> v1.3.1

* do github.com/lib/pq v1.10.0 -> v1.10.1 again ...

19 files changed, 289 insertions, 2603 deletions

diff --git a/vendor/github.com/RoaringBitmap/roaring/.gitignore b/vendor/github.com/RoaringBitmap/roaring/.gitignore
index b7943ab209..851f323dba 100644
--- a/vendor/github.com/RoaringBitmap/roaring/.gitignore
+++ b/vendor/github.com/RoaringBitmap/roaring/.gitignore
@@ -3,4 +3,3 @@ roaring-fuzz.zip
 workdir
 coverage.out
 testdata/all3.classic
-testdata/all3.msgp.snappy
diff --git a/vendor/github.com/RoaringBitmap/roaring/.travis.yml b/vendor/github.com/RoaringBitmap/roaring/.travis.yml
index 12266d7250..0a4c4e918f 100644
--- a/vendor/github.com/RoaringBitmap/roaring/.travis.yml
+++ b/vendor/github.com/RoaringBitmap/roaring/.travis.yml
@@ -17,7 +17,7 @@ branches:
   only:
     - master
 script:
-- goveralls -v -service travis-ci -ignore arraycontainer_gen.go,bitmapcontainer_gen.go,rle16_gen.go,rle_gen.go,roaringarray_gen.go,rle.go || go test
+- goveralls -v -service travis-ci -ignore rle16_gen.go,rle_gen.go,rle.go || go test
 - go test -race -run TestConcurrent*
 - go build -tags appengine
 - go test -tags appengine
diff --git a/vendor/github.com/RoaringBitmap/roaring/Makefile b/vendor/github.com/RoaringBitmap/roaring/Makefile
index 906bd72569..a22f3d330b 100644
--- a/vendor/github.com/RoaringBitmap/roaring/Makefile
+++ b/vendor/github.com/RoaringBitmap/roaring/Makefile
@@ -97,10 +97,6 @@ nuke:
 	rm -rf ./target
 	GOPATH=$(GOPATH) go clean -i ./...
 
-
-ser: 
-	go generate
-
 cover:
 	go test -coverprofile=coverage.out
 	go tool cover -html=coverage.out
diff --git a/vendor/github.com/RoaringBitmap/roaring/arraycontainer.go b/vendor/github.com/RoaringBitmap/roaring/arraycontainer.go
index f8bb29b96f..7390ba8df6 100644
--- a/vendor/github.com/RoaringBitmap/roaring/arraycontainer.go
+++ b/vendor/github.com/RoaringBitmap/roaring/arraycontainer.go
@@ -4,8 +4,6 @@ import (
 	"fmt"
 )
 
-//go:generate msgp -unexported
-
 type arrayContainer struct {
 	content []uint16
 }
@@ -485,7 +483,7 @@ func (ac *arrayContainer) orArrayCardinality(value2 *arrayContainer) int {
 func (ac *arrayContainer) lazyorArray(value2 *arrayContainer) container {
 	value1 := ac
 	maxPossibleCardinality := value1.getCardinality() + value2.getCardinality()
-	if maxPossibleCardinality > arrayLazyLowerBound { // it could be a bitmap!^M
+	if maxPossibleCardinality > arrayLazyLowerBound { // it could be a bitmap!
 		bc := newBitmapContainer()
 		for k := 0; k < len(value2.content); k++ {
 			v := value2.content[k]
diff --git a/vendor/github.com/RoaringBitmap/roaring/arraycontainer_gen.go b/vendor/github.com/RoaringBitmap/roaring/arraycontainer_gen.go
deleted file mode 100644
index 6ee670ee51..0000000000
--- a/vendor/github.com/RoaringBitmap/roaring/arraycontainer_gen.go
+++ /dev/null
@@ -1,134 +0,0 @@
-package roaring
-
-// NOTE: THIS FILE WAS PRODUCED BY THE
-// MSGP CODE GENERATION TOOL (github.com/tinylib/msgp)
-// DO NOT EDIT
-
-import "github.com/tinylib/msgp/msgp"
-
-// Deprecated: DecodeMsg implements msgp.Decodable
-func (z *arrayContainer) DecodeMsg(dc *msgp.Reader) (err error) {
-	var field []byte
-	_ = field
-	var zbzg uint32
-	zbzg, err = dc.ReadMapHeader()
-	if err != nil {
-		return
-	}
-	for zbzg > 0 {
-		zbzg--
-		field, err = dc.ReadMapKeyPtr()
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "content":
-			var zbai uint32
-			zbai, err = dc.ReadArrayHeader()
-			if err != nil {
-				return
-			}
-			if cap(z.content) >= int(zbai) {
-				z.content = (z.content)[:zbai]
-			} else {
-				z.content = make([]uint16, zbai)
-			}
-			for zxvk := range z.content {
-				z.content[zxvk], err = dc.ReadUint16()
-				if err != nil {
-					return
-				}
-			}
-		default:
-			err = dc.Skip()
-			if err != nil {
-				return
-			}
-		}
-	}
-	return
-}
-
-// Deprecated: EncodeMsg implements msgp.Encodable
-func (z *arrayContainer) EncodeMsg(en *msgp.Writer) (err error) {
-	// map header, size 1
-	// write "content"
-	err = en.Append(0x81, 0xa7, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74)
-	if err != nil {
-		return err
-	}
-	err = en.WriteArrayHeader(uint32(len(z.content)))
-	if err != nil {
-		return
-	}
-	for zxvk := range z.content {
-		err = en.WriteUint16(z.content[zxvk])
-		if err != nil {
-			return
-		}
-	}
-	return
-}
-
-// Deprecated: MarshalMsg implements msgp.Marshaler
-func (z *arrayContainer) MarshalMsg(b []byte) (o []byte, err error) {
-	o = msgp.Require(b, z.Msgsize())
-	// map header, size 1
-	// string "content"
-	o = append(o, 0x81, 0xa7, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74)
-	o = msgp.AppendArrayHeader(o, uint32(len(z.content)))
-	for zxvk := range z.content {
-		o = msgp.AppendUint16(o, z.content[zxvk])
-	}
-	return
-}
-
-// Deprecated: UnmarshalMsg implements msgp.Unmarshaler
-func (z *arrayContainer) UnmarshalMsg(bts []byte) (o []byte, err error) {
-	var field []byte
-	_ = field
-	var zcmr uint32
-	zcmr, bts, err = msgp.ReadMapHeaderBytes(bts)
-	if err != nil {
-		return
-	}
-	for zcmr > 0 {
-		zcmr--
-		field, bts, err = msgp.ReadMapKeyZC(bts)
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "content":
-			var zajw uint32
-			zajw, bts, err = msgp.ReadArrayHeaderBytes(bts)
-			if err != nil {
-				return
-			}
-			if cap(z.content) >= int(zajw) {
-				z.content = (z.content)[:zajw]
-			} else {
-				z.content = make([]uint16, zajw)
-			}
-			for zxvk := range z.content {
-				z.content[zxvk], bts, err = msgp.ReadUint16Bytes(bts)
-				if err != nil {
-					return
-				}
-			}
-		default:
-			bts, err = msgp.Skip(bts)
-			if err != nil {
-				return
-			}
-		}
-	}
-	o = bts
-	return
-}
-
-// Deprecated: Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
-func (z *arrayContainer) Msgsize() (s int) {
-	s = 1 + 8 + msgp.ArrayHeaderSize + (len(z.content) * (msgp.Uint16Size))
-	return
-}
diff --git a/vendor/github.com/RoaringBitmap/roaring/bitmapcontainer.go b/vendor/github.com/RoaringBitmap/roaring/bitmapcontainer.go
index e09b091f30..b576c2ac85 100644
--- a/vendor/github.com/RoaringBitmap/roaring/bitmapcontainer.go
+++ b/vendor/github.com/RoaringBitmap/roaring/bitmapcontainer.go
@@ -5,8 +5,6 @@ import (
 	"unsafe"
 )
 
-//go:generate msgp -unexported
-
 type bitmapContainer struct {
 	cardinality int
 	bitmap      []uint64
@@ -115,7 +113,7 @@ type bitmapContainerShortIterator struct {
 
 func (bcsi *bitmapContainerShortIterator) next() uint16 {
 	j := bcsi.i
-	bcsi.i = bcsi.ptr.NextSetBit(bcsi.i + 1)
+	bcsi.i = bcsi.ptr.NextSetBit(uint(bcsi.i) + 1)
 	return uint16(j)
 }
 func (bcsi *bitmapContainerShortIterator) hasNext() bool {
@@ -128,7 +126,7 @@ func (bcsi *bitmapContainerShortIterator) peekNext() uint16 {
 
 func (bcsi *bitmapContainerShortIterator) advanceIfNeeded(minval uint16) {
 	if bcsi.hasNext() && bcsi.peekNext() < minval {
-		bcsi.i = bcsi.ptr.NextSetBit(int(minval))
+		bcsi.i = bcsi.ptr.NextSetBit(uint(minval))
 	}
 }
 
@@ -1009,20 +1007,23 @@ func (bc *bitmapContainer) fillArray(container []uint16) {
 	}
 }
 
-func (bc *bitmapContainer) NextSetBit(i int) int {
-	x := i / 64
-	if x >= len(bc.bitmap) {
+func (bc *bitmapContainer) NextSetBit(i uint) int {
+	var (
+		x      = i / 64
+		length = uint(len(bc.bitmap))
+	)
+	if x >= length {
 		return -1
 	}
 	w := bc.bitmap[x]
 	w = w >> uint(i%64)
 	if w != 0 {
-		return i + countTrailingZeros(w)
+		return int(i) + countTrailingZeros(w)
 	}
 	x++
-	for ; x < len(bc.bitmap); x++ {
+	for ; x < length; x++ {
 		if bc.bitmap[x] != 0 {
-			return (x * 64) + countTrailingZeros(bc.bitmap[x])
+			return int(x*64) + countTrailingZeros(bc.bitmap[x])
 		}
 	}
 	return -1
diff --git a/vendor/github.com/RoaringBitmap/roaring/bitmapcontainer_gen.go b/vendor/github.com/RoaringBitmap/roaring/bitmapcontainer_gen.go
deleted file mode 100644
index 9b5a465f38..0000000000
--- a/vendor/github.com/RoaringBitmap/roaring/bitmapcontainer_gen.go
+++ /dev/null
@@ -1,415 +0,0 @@
-package roaring
-
-// NOTE: THIS FILE WAS PRODUCED BY THE
-// MSGP CODE GENERATION TOOL (github.com/tinylib/msgp)
-// DO NOT EDIT
-
-import "github.com/tinylib/msgp/msgp"
-
-// Deprecated: DecodeMsg implements msgp.Decodable
-func (z *bitmapContainer) DecodeMsg(dc *msgp.Reader) (err error) {
-	var field []byte
-	_ = field
-	var zbzg uint32
-	zbzg, err = dc.ReadMapHeader()
-	if err != nil {
-		return
-	}
-	for zbzg > 0 {
-		zbzg--
-		field, err = dc.ReadMapKeyPtr()
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "cardinality":
-			z.cardinality, err = dc.ReadInt()
-			if err != nil {
-				return
-			}
-		case "bitmap":
-			var zbai uint32
-			zbai, err = dc.ReadArrayHeader()
-			if err != nil {
-				return
-			}
-			if cap(z.bitmap) >= int(zbai) {
-				z.bitmap = (z.bitmap)[:zbai]
-			} else {
-				z.bitmap = make([]uint64, zbai)
-			}
-			for zxvk := range z.bitmap {
-				z.bitmap[zxvk], err = dc.ReadUint64()
-				if err != nil {
-					return
-				}
-			}
-		default:
-			err = dc.Skip()
-			if err != nil {
-				return
-			}
-		}
-	}
-	return
-}
-
-// Deprecated: EncodeMsg implements msgp.Encodable
-func (z *bitmapContainer) EncodeMsg(en *msgp.Writer) (err error) {
-	// map header, size 2
-	// write "cardinality"
-	err = en.Append(0x82, 0xab, 0x63, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79)
-	if err != nil {
-		return err
-	}
-	err = en.WriteInt(z.cardinality)
-	if err != nil {
-		return
-	}
-	// write "bitmap"
-	err = en.Append(0xa6, 0x62, 0x69, 0x74, 0x6d, 0x61, 0x70)
-	if err != nil {
-		return err
-	}
-	err = en.WriteArrayHeader(uint32(len(z.bitmap)))
-	if err != nil {
-		return
-	}
-	for zxvk := range z.bitmap {
-		err = en.WriteUint64(z.bitmap[zxvk])
-		if err != nil {
-			return
-		}
-	}
-	return
-}
-
-// Deprecated: MarshalMsg implements msgp.Marshaler
-func (z *bitmapContainer) MarshalMsg(b []byte) (o []byte, err error) {
-	o = msgp.Require(b, z.Msgsize())
-	// map header, size 2
-	// string "cardinality"
-	o = append(o, 0x82, 0xab, 0x63, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79)
-	o = msgp.AppendInt(o, z.cardinality)
-	// string "bitmap"
-	o = append(o, 0xa6, 0x62, 0x69, 0x74, 0x6d, 0x61, 0x70)
-	o = msgp.AppendArrayHeader(o, uint32(len(z.bitmap)))
-	for zxvk := range z.bitmap {
-		o = msgp.AppendUint64(o, z.bitmap[zxvk])
-	}
-	return
-}
-
-// Deprecated: UnmarshalMsg implements msgp.Unmarshaler
-func (z *bitmapContainer) UnmarshalMsg(bts []byte) (o []byte, err error) {
-	var field []byte
-	_ = field
-	var zcmr uint32
-	zcmr, bts, err = msgp.ReadMapHeaderBytes(bts)
-	if err != nil {
-		return
-	}
-	for zcmr > 0 {
-		zcmr--
-		field, bts, err = msgp.ReadMapKeyZC(bts)
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "cardinality":
-			z.cardinality, bts, err = msgp.ReadIntBytes(bts)
-			if err != nil {
-				return
-			}
-		case "bitmap":
-			var zajw uint32
-			zajw, bts, err = msgp.ReadArrayHeaderBytes(bts)
-			if err != nil {
-				return
-			}
-			if cap(z.bitmap) >= int(zajw) {
-				z.bitmap = (z.bitmap)[:zajw]
-			} else {
-				z.bitmap = make([]uint64, zajw)
-			}
-			for zxvk := range z.bitmap {
-				z.bitmap[zxvk], bts, err = msgp.ReadUint64Bytes(bts)
-				if err != nil {
-					return
-				}
-			}
-		default:
-			bts, err = msgp.Skip(bts)
-			if err != nil {
-				return
-			}
-		}
-	}
-	o = bts
-	return
-}
-
-// Deprecated: Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
-func (z *bitmapContainer) Msgsize() (s int) {
-	s = 1 + 12 + msgp.IntSize + 7 + msgp.ArrayHeaderSize + (len(z.bitmap) * (msgp.Uint64Size))
-	return
-}
-
-// Deprecated: DecodeMsg implements msgp.Decodable
-func (z *bitmapContainerShortIterator) DecodeMsg(dc *msgp.Reader) (err error) {
-	var field []byte
-	_ = field
-	var zhct uint32
-	zhct, err = dc.ReadMapHeader()
-	if err != nil {
-		return
-	}
-	for zhct > 0 {
-		zhct--
-		field, err = dc.ReadMapKeyPtr()
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "ptr":
-			if dc.IsNil() {
-				err = dc.ReadNil()
-				if err != nil {
-					return
-				}
-				z.ptr = nil
-			} else {
-				if z.ptr == nil {
-					z.ptr = new(bitmapContainer)
-				}
-				var zcua uint32
-				zcua, err = dc.ReadMapHeader()
-				if err != nil {
-					return
-				}
-				for zcua > 0 {
-					zcua--
-					field, err = dc.ReadMapKeyPtr()
-					if err != nil {
-						return
-					}
-					switch msgp.UnsafeString(field) {
-					case "cardinality":
-						z.ptr.cardinality, err = dc.ReadInt()
-						if err != nil {
-							return
-						}
-					case "bitmap":
-						var zxhx uint32
-						zxhx, err = dc.ReadArrayHeader()
-						if err != nil {
-							return
-						}
-						if cap(z.ptr.bitmap) >= int(zxhx) {
-							z.ptr.bitmap = (z.ptr.bitmap)[:zxhx]
-						} else {
-							z.ptr.bitmap = make([]uint64, zxhx)
-						}
-						for zwht := range z.ptr.bitmap {
-							z.ptr.bitmap[zwht], err = dc.ReadUint64()
-							if err != nil {
-								return
-							}
-						}
-					default:
-						err = dc.Skip()
-						if err != nil {
-							return
-						}
-					}
-				}
-			}
-		case "i":
-			z.i, err = dc.ReadInt()
-			if err != nil {
-				return
-			}
-		default:
-			err = dc.Skip()
-			if err != nil {
-				return
-			}
-		}
-	}
-	return
-}
-
-// Deprecated: EncodeMsg implements msgp.Encodable
-func (z *bitmapContainerShortIterator) EncodeMsg(en *msgp.Writer) (err error) {
-	// map header, size 2
-	// write "ptr"
-	err = en.Append(0x82, 0xa3, 0x70, 0x74, 0x72)
-	if err != nil {
-		return err
-	}
-	if z.ptr == nil {
-		err = en.WriteNil()
-		if err != nil {
-			return
-		}
-	} else {
-		// map header, size 2
-		// write "cardinality"
-		err = en.Append(0x82, 0xab, 0x63, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79)
-		if err != nil {
-			return err
-		}
-		err = en.WriteInt(z.ptr.cardinality)
-		if err != nil {
-			return
-		}
-		// write "bitmap"
-		err = en.Append(0xa6, 0x62, 0x69, 0x74, 0x6d, 0x61, 0x70)
-		if err != nil {
-			return err
-		}
-		err = en.WriteArrayHeader(uint32(len(z.ptr.bitmap)))
-		if err != nil {
-			return
-		}
-		for zwht := range z.ptr.bitmap {
-			err = en.WriteUint64(z.ptr.bitmap[zwht])
-			if err != nil {
-				return
-			}
-		}
-	}
-	// write "i"
-	err = en.Append(0xa1, 0x69)
-	if err != nil {
-		return err
-	}
-	err = en.WriteInt(z.i)
-	if err != nil {
-		return
-	}
-	return
-}
-
-// Deprecated: MarshalMsg implements msgp.Marshaler
-func (z *bitmapContainerShortIterator) MarshalMsg(b []byte) (o []byte, err error) {
-	o = msgp.Require(b, z.Msgsize())
-	// map header, size 2
-	// string "ptr"
-	o = append(o, 0x82, 0xa3, 0x70, 0x74, 0x72)
-	if z.ptr == nil {
-		o = msgp.AppendNil(o)
-	} else {
-		// map header, size 2
-		// string "cardinality"
-		o = append(o, 0x82, 0xab, 0x63, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79)
-		o = msgp.AppendInt(o, z.ptr.cardinality)
-		// string "bitmap"
-		o = append(o, 0xa6, 0x62, 0x69, 0x74, 0x6d, 0x61, 0x70)
-		o = msgp.AppendArrayHeader(o, uint32(len(z.ptr.bitmap)))
-		for zwht := range z.ptr.bitmap {
-			o = msgp.AppendUint64(o, z.ptr.bitmap[zwht])
-		}
-	}
-	// string "i"
-	o = append(o, 0xa1, 0x69)
-	o = msgp.AppendInt(o, z.i)
-	return
-}
-
-// Deprecated: UnmarshalMsg implements msgp.Unmarshaler
-func (z *bitmapContainerShortIterator) UnmarshalMsg(bts []byte) (o []byte, err error) {
-	var field []byte
-	_ = field
-	var zlqf uint32
-	zlqf, bts, err = msgp.ReadMapHeaderBytes(bts)
-	if err != nil {
-		return
-	}
-	for zlqf > 0 {
-		zlqf--
-		field, bts, err = msgp.ReadMapKeyZC(bts)
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "ptr":
-			if msgp.IsNil(bts) {
-				bts, err = msgp.ReadNilBytes(bts)
-				if err != nil {
-					return
-				}
-				z.ptr = nil
-			} else {
-				if z.ptr == nil {
-					z.ptr = new(bitmapContainer)
-				}
-				var zdaf uint32
-				zdaf, bts, err = msgp.ReadMapHeaderBytes(bts)
-				if err != nil {
-					return
-				}
-				for zdaf > 0 {
-					zdaf--
-					field, bts, err = msgp.ReadMapKeyZC(bts)
-					if err != nil {
-						return
-					}
-					switch msgp.UnsafeString(field) {
-					case "cardinality":
-						z.ptr.cardinality, bts, err = msgp.ReadIntBytes(bts)
-						if err != nil {
-							return
-						}
-					case "bitmap":
-						var zpks uint32
-						zpks, bts, err = msgp.ReadArrayHeaderBytes(bts)
-						if err != nil {
-							return
-						}
-						if cap(z.ptr.bitmap) >= int(zpks) {
-							z.ptr.bitmap = (z.ptr.bitmap)[:zpks]
-						} else {
-							z.ptr.bitmap = make([]uint64, zpks)
-						}
-						for zwht := range z.ptr.bitmap {
-							z.ptr.bitmap[zwht], bts, err = msgp.ReadUint64Bytes(bts)
-							if err != nil {
-								return
-							}
-						}
-					default:
-						bts, err = msgp.Skip(bts)
-						if err != nil {
-							return
-						}
-					}
-				}
-			}
-		case "i":
-			z.i, bts, err = msgp.ReadIntBytes(bts)
-			if err != nil {
-				return
-			}
-		default:
-			bts, err = msgp.Skip(bts)
-			if err != nil {
-				return
-			}
-		}
-	}
-	o = bts
-	return
-}
-
-// Deprecated: Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
-func (z *bitmapContainerShortIterator) Msgsize() (s int) {
-	s = 1 + 4
-	if z.ptr == nil {
-		s += msgp.NilSize
-	} else {
-		s += 1 + 12 + msgp.IntSize + 7 + msgp.ArrayHeaderSize + (len(z.ptr.bitmap) * (msgp.Uint64Size))
-	}
-	s += 2 + msgp.IntSize
-	return
-}
diff --git a/vendor/github.com/RoaringBitmap/roaring/byte_input.go b/vendor/github.com/RoaringBitmap/roaring/byte_input.go
deleted file mode 100644
index f7a98a1d40..0000000000
--- a/vendor/github.com/RoaringBitmap/roaring/byte_input.go
+++ /dev/null
@@ -1,161 +0,0 @@
-package roaring
-
-import (
-	"encoding/binary"
-	"io"
-)
-
-type byteInput interface {
-	// next returns a slice containing the next n bytes from the buffer,
-	// advancing the buffer as if the bytes had been returned by Read.
-	next(n int) ([]byte, error)
-	// readUInt32 reads uint32 with LittleEndian order
-	readUInt32() (uint32, error)
-	// readUInt16 reads uint16 with LittleEndian order
-	readUInt16() (uint16, error)
-	// getReadBytes returns read bytes
-	getReadBytes() int64
-	// skipBytes skips exactly n bytes
-	skipBytes(n int) error
-}
-
-func newByteInputFromReader(reader io.Reader) byteInput {
-	return &byteInputAdapter{
-		r:         reader,
-		readBytes: 0,
-	}
-}
-
-func newByteInput(buf []byte) byteInput {
-	return &byteBuffer{
-		buf: buf,
-		off: 0,
-	}
-}
-
-type byteBuffer struct {
-	buf []byte
-	off int
-}
-
-// next returns a slice containing the next n bytes from the reader
-// If there are fewer bytes than the given n, io.ErrUnexpectedEOF will be returned
-func (b *byteBuffer) next(n int) ([]byte, error) {
-	m := len(b.buf) - b.off
-
-	if n > m {
-		return nil, io.ErrUnexpectedEOF
-	}
-
-	data := b.buf[b.off : b.off+n]
-	b.off += n
-
-	return data, nil
-}
-
-// readUInt32 reads uint32 with LittleEndian order
-func (b *byteBuffer) readUInt32() (uint32, error) {
-	if len(b.buf)-b.off < 4 {
-		return 0, io.ErrUnexpectedEOF
-	}
-
-	v := binary.LittleEndian.Uint32(b.buf[b.off:])
-	b.off += 4
-
-	return v, nil
-}
-
-// readUInt16 reads uint16 with LittleEndian order
-func (b *byteBuffer) readUInt16() (uint16, error) {
-	if len(b.buf)-b.off < 2 {
-		return 0, io.ErrUnexpectedEOF
-	}
-
-	v := binary.LittleEndian.Uint16(b.buf[b.off:])
-	b.off += 2
-
-	return v, nil
-}
-
-// getReadBytes returns read bytes
-func (b *byteBuffer) getReadBytes() int64 {
-	return int64(b.off)
-}
-
-// skipBytes skips exactly n bytes
-func (b *byteBuffer) skipBytes(n int) error {
-	m := len(b.buf) - b.off
-
-	if n > m {
-		return io.ErrUnexpectedEOF
-	}
-
-	b.off += n
-
-	return nil
-}
-
-// reset resets the given buffer with a new byte slice
-func (b *byteBuffer) reset(buf []byte) {
-	b.buf = buf
-	b.off = 0
-}
-
-type byteInputAdapter struct {
-	r         io.Reader
-	readBytes int
-}
-
-// next returns a slice containing the next n bytes from the buffer,
-// advancing the buffer as if the bytes had been returned by Read.
-func (b *byteInputAdapter) next(n int) ([]byte, error) {
-	buf := make([]byte, n)
-	m, err := io.ReadAtLeast(b.r, buf, n)
-	b.readBytes += m
-
-	if err != nil {
-		return nil, err
-	}
-
-	return buf, nil
-}
-
-// readUInt32 reads uint32 with LittleEndian order
-func (b *byteInputAdapter) readUInt32() (uint32, error) {
-	buf, err := b.next(4)
-
-	if err != nil {
-		return 0, err
-	}
-
-	return binary.LittleEndian.Uint32(buf), nil
-}
-
-// readUInt16 reads uint16 with LittleEndian order
-func (b *byteInputAdapter) readUInt16() (uint16, error) {
-	buf, err := b.next(2)
-
-	if err != nil {
-		return 0, err
-	}
-
-	return binary.LittleEndian.Uint16(buf), nil
-}
-
-// getReadBytes returns read bytes
-func (b *byteInputAdapter) getReadBytes() int64 {
-	return int64(b.readBytes)
-}
-
-// skipBytes skips exactly n bytes
-func (b *byteInputAdapter) skipBytes(n int) error {
-	_, err := b.next(n)
-
-	return err
-}
-
-// reset resets the given buffer with a new stream
-func (b *byteInputAdapter) reset(stream io.Reader) {
-	b.r = stream
-	b.readBytes = 0
-}
diff --git a/vendor/github.com/RoaringBitmap/roaring/go.mod b/vendor/github.com/RoaringBitmap/roaring/go.mod
index 5e9db36bac..4667133cf3 100644
--- a/vendor/github.com/RoaringBitmap/roaring/go.mod
+++ b/vendor/github.com/RoaringBitmap/roaring/go.mod
@@ -11,7 +11,6 @@ require (
 	github.com/mschoch/smat v0.0.0-20160514031455-90eadee771ae
 	github.com/philhofer/fwd v1.0.0 // indirect
 	github.com/stretchr/testify v1.4.0
-	github.com/tinylib/msgp v1.1.0
 	github.com/willf/bitset v1.1.10
 	golang.org/x/lint v0.0.0-20200302205851-738671d3881b // indirect
 	golang.org/x/tools v0.0.0-20200928182047-19e03678916f // indirect
diff --git a/vendor/github.com/RoaringBitmap/roaring/go.sum b/vendor/github.com/RoaringBitmap/roaring/go.sum
index c01900e6d7..8798080871 100644
--- a/vendor/github.com/RoaringBitmap/roaring/go.sum
+++ b/vendor/github.com/RoaringBitmap/roaring/go.sum
@@ -20,8 +20,6 @@ github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/tinylib/msgp v1.1.0 h1:9fQd+ICuRIu/ue4vxJZu6/LzxN0HwMds2nq/0cFvxHU=
-github.com/tinylib/msgp v1.1.0/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE=
 github.com/willf/bitset v1.1.10 h1:NotGKqX0KwQ72NUzqrjZq5ipPNDQex9lo3WpaS8L2sc=
 github.com/willf/bitset v1.1.10/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPySAYV4=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
diff --git a/vendor/github.com/RoaringBitmap/roaring/internal/byte_input.go b/vendor/github.com/RoaringBitmap/roaring/internal/byte_input.go
new file mode 100644
index 0000000000..3e5490a9df
--- /dev/null
+++ b/vendor/github.com/RoaringBitmap/roaring/internal/byte_input.go
@@ -0,0 +1,166 @@
+package internal
+
+import (
+	"encoding/binary"
+	"io"
+)
+
+// ByteInput typed interface around io.Reader or raw bytes
+type ByteInput interface {
+	// Next returns a slice containing the next n bytes from the buffer,
+	// advancing the buffer as if the bytes had been returned by Read.
+	Next(n int) ([]byte, error)
+	// ReadUInt32 reads uint32 with LittleEndian order
+	ReadUInt32() (uint32, error)
+	// ReadUInt16 reads uint16 with LittleEndian order
+	ReadUInt16() (uint16, error)
+	// GetReadBytes returns read bytes
+	GetReadBytes() int64
+	// SkipBytes skips exactly n bytes
+	SkipBytes(n int) error
+}
+
+// NewByteInputFromReader creates reader wrapper
+func NewByteInputFromReader(reader io.Reader) ByteInput {
+	return &ByteInputAdapter{
+		r:         reader,
+		readBytes: 0,
+	}
+}
+
+// NewByteInput creates raw bytes wrapper
+func NewByteInput(buf []byte) ByteInput {
+	return &ByteBuffer{
+		buf: buf,
+		off: 0,
+	}
+}
+
+// ByteBuffer raw bytes wrapper
+type ByteBuffer struct {
+	buf []byte
+	off int
+}
+
+// Next returns a slice containing the next n bytes from the reader
+// If there are fewer bytes than the given n, io.ErrUnexpectedEOF will be returned
+func (b *ByteBuffer) Next(n int) ([]byte, error) {
+	m := len(b.buf) - b.off
+
+	if n > m {
+		return nil, io.ErrUnexpectedEOF
+	}
+
+	data := b.buf[b.off : b.off+n]
+	b.off += n
+
+	return data, nil
+}
+
+// ReadUInt32 reads uint32 with LittleEndian order
+func (b *ByteBuffer) ReadUInt32() (uint32, error) {
+	if len(b.buf)-b.off < 4 {
+		return 0, io.ErrUnexpectedEOF
+	}
+
+	v := binary.LittleEndian.Uint32(b.buf[b.off:])
+	b.off += 4
+
+	return v, nil
+}
+
+// ReadUInt16 reads uint16 with LittleEndian order
+func (b *ByteBuffer) ReadUInt16() (uint16, error) {
+	if len(b.buf)-b.off < 2 {
+		return 0, io.ErrUnexpectedEOF
+	}
+
+	v := binary.LittleEndian.Uint16(b.buf[b.off:])
+	b.off += 2
+
+	return v, nil
+}
+
+// GetReadBytes returns read bytes
+func (b *ByteBuffer) GetReadBytes() int64 {
+	return int64(b.off)
+}
+
+// SkipBytes skips exactly n bytes
+func (b *ByteBuffer) SkipBytes(n int) error {
+	m := len(b.buf) - b.off
+
+	if n > m {
+		return io.ErrUnexpectedEOF
+	}
+
+	b.off += n
+
+	return nil
+}
+
+// Reset resets the given buffer with a new byte slice
+func (b *ByteBuffer) Reset(buf []byte) {
+	b.buf = buf
+	b.off = 0
+}
+
+// ByteInputAdapter reader wrapper
+type ByteInputAdapter struct {
+	r         io.Reader
+	readBytes int
+}
+
+// Next returns a slice containing the next n bytes from the buffer,
+// advancing the buffer as if the bytes had been returned by Read.
+func (b *ByteInputAdapter) Next(n int) ([]byte, error) {
+	buf := make([]byte, n)
+	m, err := io.ReadAtLeast(b.r, buf, n)
+	b.readBytes += m
+
+	if err != nil {
+		return nil, err
+	}
+
+	return buf, nil
+}
+
+// ReadUInt32 reads uint32 with LittleEndian order
+func (b *ByteInputAdapter) ReadUInt32() (uint32, error) {
+	buf, err := b.Next(4)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return binary.LittleEndian.Uint32(buf), nil
+}
+
+// ReadUInt16 reads uint16 with LittleEndian order
+func (b *ByteInputAdapter) ReadUInt16() (uint16, error) {
+	buf, err := b.Next(2)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return binary.LittleEndian.Uint16(buf), nil
+}
+
+// GetReadBytes returns read bytes
+func (b *ByteInputAdapter) GetReadBytes() int64 {
+	return int64(b.readBytes)
+}
+
+// SkipBytes skips exactly n bytes
+func (b *ByteInputAdapter) SkipBytes(n int) error {
+	_, err := b.Next(n)
+
+	return err
+}
+
+// Reset resets the given buffer with a new stream
+func (b *ByteInputAdapter) Reset(stream io.Reader) {
+	b.r = stream
+	b.readBytes = 0
+}
diff --git a/vendor/github.com/RoaringBitmap/roaring/internal/pools.go b/vendor/github.com/RoaringBitmap/roaring/internal/pools.go
new file mode 100644
index 0000000000..d2583568d0
--- /dev/null
+++ b/vendor/github.com/RoaringBitmap/roaring/internal/pools.go
@@ -0,0 +1,21 @@
+package internal
+
+import (
+	"sync"
+)
+
+var (
+	// ByteInputAdapterPool shared pool
+	ByteInputAdapterPool = sync.Pool{
+		New: func() interface{} {
+			return &ByteInputAdapter{}
+		},
+	}
+
+	// ByteBufferPool shared pool
+	ByteBufferPool = sync.Pool{
+		New: func() interface{} {
+			return &ByteBuffer{}
+		},
+	}
+)
diff --git a/vendor/github.com/RoaringBitmap/roaring/parallel.go b/vendor/github.com/RoaringBitmap/roaring/parallel.go
index 2af1aed48e..6d8e29360a 100644
--- a/vendor/github.com/RoaringBitmap/roaring/parallel.go
+++ b/vendor/github.com/RoaringBitmap/roaring/parallel.go
@@ -166,7 +166,6 @@ func appenderRoutine(bitmapChan chan<- *Bitmap, resultChan <-chan keyedContainer
 			make([]container, 0, expectedKeys),
 			make([]bool, 0, expectedKeys),
 			false,
-			nil,
 		},
 	}
 	for i := range keys {
diff --git a/vendor/github.com/RoaringBitmap/roaring/roaring.go b/vendor/github.com/RoaringBitmap/roaring/roaring.go
index 2afb39570a..b78f83cc27 100644
--- a/vendor/github.com/RoaringBitmap/roaring/roaring.go
+++ b/vendor/github.com/RoaringBitmap/roaring/roaring.go
@@ -11,7 +11,8 @@ import (
 	"fmt"
 	"io"
 	"strconv"
-	"sync"
+
+	"github.com/RoaringBitmap/roaring/internal"
 )
 
 // Bitmap represents a compressed bitmap where you can add integers.
@@ -52,27 +53,19 @@ func (rb *Bitmap) ToBytes() ([]byte, error) {
 	return rb.highlowcontainer.toBytes()
 }
 
-// Deprecated: WriteToMsgpack writes a msgpack2/snappy-streaming compressed serialized
-// version of this bitmap to stream. The format is not
-// compatible with the WriteTo() format, and is
-// experimental: it may produce smaller on disk
-// footprint and/or be faster to read, depending
-// on your content. Currently only the Go roaring
-// implementation supports this format.
-func (rb *Bitmap) WriteToMsgpack(stream io.Writer) (int64, error) {
-	return 0, rb.highlowcontainer.writeToMsgpack(stream)
-}
-
 // ReadFrom reads a serialized version of this bitmap from stream.
 // The format is compatible with other RoaringBitmap
 // implementations (Java, C) and is documented here:
 // https://github.com/RoaringBitmap/RoaringFormatSpec
-func (rb *Bitmap) ReadFrom(reader io.Reader) (p int64, err error) {
-	stream := byteInputAdapterPool.Get().(*byteInputAdapter)
-	stream.reset(reader)
+// Since io.Reader is regarded as a stream and cannot be read twice.
+// So add cookieHeader to accept the 4-byte data that has been read in roaring64.ReadFrom.
+// It is not necessary to pass cookieHeader when call roaring.ReadFrom to read the roaring32 data directly.
+func (rb *Bitmap) ReadFrom(reader io.Reader, cookieHeader ...byte) (p int64, err error) {
+	stream := internal.ByteInputAdapterPool.Get().(*internal.ByteInputAdapter)
+	stream.Reset(reader)
 
-	p, err = rb.highlowcontainer.readFrom(stream)
-	byteInputAdapterPool.Put(stream)
+	p, err = rb.highlowcontainer.readFrom(stream, cookieHeader...)
+	internal.ByteInputAdapterPool.Put(stream)
 
 	return
 }
@@ -100,29 +93,15 @@ func (rb *Bitmap) ReadFrom(reader io.Reader) (p int64, err error) {
 // call CloneCopyOnWriteContainers on all such bitmaps.
 //
 func (rb *Bitmap) FromBuffer(buf []byte) (p int64, err error) {
-	stream := byteBufferPool.Get().(*byteBuffer)
-	stream.reset(buf)
+	stream := internal.ByteBufferPool.Get().(*internal.ByteBuffer)
+	stream.Reset(buf)
 
 	p, err = rb.highlowcontainer.readFrom(stream)
-	byteBufferPool.Put(stream)
+	internal.ByteBufferPool.Put(stream)
 
 	return
 }
 
-var (
-	byteBufferPool = sync.Pool{
-		New: func() interface{} {
-			return &byteBuffer{}
-		},
-	}
-
-	byteInputAdapterPool = sync.Pool{
-		New: func() interface{} {
-			return &byteInputAdapter{}
-		},
-	}
-)
-
 // RunOptimize attempts to further compress the runs of consecutive values found in the bitmap
 func (rb *Bitmap) RunOptimize() {
 	rb.highlowcontainer.runOptimize()
@@ -133,14 +112,6 @@ func (rb *Bitmap) HasRunCompression() bool {
 	return rb.highlowcontainer.hasRunCompression()
 }
 
-// Deprecated: ReadFromMsgpack reads a msgpack2/snappy-streaming serialized
-// version of this bitmap from stream. The format is
-// expected is that written by the WriteToMsgpack()
-// call; see additional notes there.
-func (rb *Bitmap) ReadFromMsgpack(stream io.Reader) (int64, error) {
-	return 0, rb.highlowcontainer.readFromMsgpack(stream)
-}
-
 // MarshalBinary implements the encoding.BinaryMarshaler interface for the bitmap
 // (same as ToBytes)
 func (rb *Bitmap) MarshalBinary() ([]byte, error) {
diff --git a/vendor/github.com/RoaringBitmap/roaring/roaringarray.go b/vendor/github.com/RoaringBitmap/roaring/roaringarray.go
index d0c832b1b5..4aefc6a316 100644
--- a/vendor/github.com/RoaringBitmap/roaring/roaringarray.go
+++ b/vendor/github.com/RoaringBitmap/roaring/roaringarray.go
@@ -5,13 +5,9 @@ import (
 	"encoding/binary"
 	"fmt"
 	"io"
-
-	snappy "github.com/glycerine/go-unsnap-stream"
-	"github.com/tinylib/msgp/msgp"
+	"github.com/RoaringBitmap/roaring/internal"
 )
 
-//go:generate msgp -unexported
-
 type container interface {
 	addOffset(uint16) []container
 
@@ -103,18 +99,6 @@ type roaringArray struct {
 	containers      []container `msg:"-"` // don't try to serialize directly.
 	needCopyOnWrite []bool
 	copyOnWrite     bool
-
-	// conserz is used at serialization time
-	// to serialize containers. Otherwise empty.
-	conserz []containerSerz
-}
-
-// containerSerz facilitates serializing container (tricky to
-// serialize because it is an interface) by providing a
-// light wrapper with a type identifier.
-type containerSerz struct {
-	t contype  `msg:"t"` // type
-	r msgp.Raw `msg:"r"` // Raw msgpack of the actual container type
 }
 
 func newRoaringArray() *roaringArray {
@@ -246,7 +230,6 @@ func (ra *roaringArray) resize(newsize int) {
 func (ra *roaringArray) clear() {
 	ra.resize(0)
 	ra.copyOnWrite = false
-	ra.conserz = nil
 }
 
 func (ra *roaringArray) clone() *roaringArray {
@@ -566,11 +549,19 @@ func (ra *roaringArray) toBytes() ([]byte, error) {
 	return buf.Bytes(), err
 }
 
-func (ra *roaringArray) readFrom(stream byteInput) (int64, error) {
-	cookie, err := stream.readUInt32()
-
-	if err != nil {
-		return stream.getReadBytes(), fmt.Errorf("error in roaringArray.readFrom: could not read initial cookie: %s", err)
+func (ra *roaringArray) readFrom(stream internal.ByteInput, cookieHeader ...byte) (int64, error) {
+  var cookie uint32
+	var err error
+  if len(cookieHeader) > 0 && len(cookieHeader) != 4 {
+		return int64(len(cookieHeader)), fmt.Errorf("error in roaringArray.readFrom: could not read initial cookie: incorrect size of cookie header")
+	}
+	if len(cookieHeader) == 4 {
+		cookie = binary.LittleEndian.Uint32(cookieHeader)
+	} else {
+		cookie, err = stream.ReadUInt32()
+		if err != nil {
+			return stream.GetReadBytes(), fmt.Errorf("error in roaringArray.readFrom: could not read initial cookie: %s", err)
+		}
 	}
 
 	var size uint32
@@ -580,37 +571,36 @@ func (ra *roaringArray) readFrom(stream byteInput) (int64, error) {
 		size = uint32(uint16(cookie>>16) + 1)
 		// create is-run-container bitmap
 		isRunBitmapSize := (int(size) + 7) / 8
-		isRunBitmap, err = stream.next(isRunBitmapSize)
+		isRunBitmap, err = stream.Next(isRunBitmapSize)
 
 		if err != nil {
-			return stream.getReadBytes(), fmt.Errorf("malformed bitmap, failed to read is-run bitmap, got: %s", err)
+			return stream.GetReadBytes(), fmt.Errorf("malformed bitmap, failed to read is-run bitmap, got: %s", err)
 		}
 	} else if cookie == serialCookieNoRunContainer {
-		size, err = stream.readUInt32()
-
+		size, err = stream.ReadUInt32()
 		if err != nil {
-			return stream.getReadBytes(), fmt.Errorf("malformed bitmap, failed to read a bitmap size: %s", err)
+			return stream.GetReadBytes(), fmt.Errorf("malformed bitmap, failed to read a bitmap size: %s", err)
 		}
 	} else {
-		return stream.getReadBytes(), fmt.Errorf("error in roaringArray.readFrom: did not find expected serialCookie in header")
+		return stream.GetReadBytes(), fmt.Errorf("error in roaringArray.readFrom: did not find expected serialCookie in header")
 	}
 
 	if size > (1 << 16) {
-		return stream.getReadBytes(), fmt.Errorf("it is logically impossible to have more than (1<<16) containers")
+		return stream.GetReadBytes(), fmt.Errorf("it is logically impossible to have more than (1<<16) containers")
 	}
 
 	// descriptive header
-	buf, err := stream.next(2 * 2 * int(size))
+	buf, err := stream.Next(2 * 2 * int(size))
 
 	if err != nil {
-		return stream.getReadBytes(), fmt.Errorf("failed to read descriptive header: %s", err)
+		return stream.GetReadBytes(), fmt.Errorf("failed to read descriptive header: %s", err)
 	}
 
 	keycard := byteSliceAsUint16Slice(buf)
 
 	if isRunBitmap == nil || size >= noOffsetThreshold {
-		if err := stream.skipBytes(int(size) * 4); err != nil {
-			return stream.getReadBytes(), fmt.Errorf("failed to skip bytes: %s", err)
+		if err := stream.SkipBytes(int(size) * 4); err != nil {
+			return stream.GetReadBytes(), fmt.Errorf("failed to skip bytes: %s", err)
 		}
 	}
 
@@ -641,16 +631,16 @@ func (ra *roaringArray) readFrom(stream byteInput) (int64, error) {
 
 		if isRunBitmap != nil && isRunBitmap[i/8]&(1<<(i%8)) != 0 {
 			// run container
-			nr, err := stream.readUInt16()
+			nr, err := stream.ReadUInt16()
 
 			if err != nil {
 				return 0, fmt.Errorf("failed to read runtime container size: %s", err)
 			}
 
-			buf, err := stream.next(int(nr) * 4)
+			buf, err := stream.Next(int(nr) * 4)
 
 			if err != nil {
-				return stream.getReadBytes(), fmt.Errorf("failed to read runtime container content: %s", err)
+				return stream.GetReadBytes(), fmt.Errorf("failed to read runtime container content: %s", err)
 			}
 
 			nb := runContainer16{
@@ -661,10 +651,10 @@ func (ra *roaringArray) readFrom(stream byteInput) (int64, error) {
 			ra.containers[i] = &nb
 		} else if card > arrayDefaultMaxSize {
 			// bitmap container
-			buf, err := stream.next(arrayDefaultMaxSize * 2)
+			buf, err := stream.Next(arrayDefaultMaxSize * 2)
 
 			if err != nil {
-				return stream.getReadBytes(), fmt.Errorf("failed to read bitmap container: %s", err)
+				return stream.GetReadBytes(), fmt.Errorf("failed to read bitmap container: %s", err)
 			}
 
 			nb := bitmapContainer{
@@ -675,10 +665,10 @@ func (ra *roaringArray) readFrom(stream byteInput) (int64, error) {
 			ra.containers[i] = &nb
 		} else {
 			// array container
-			buf, err := stream.next(card * 2)
+			buf, err := stream.Next(card * 2)
 
 			if err != nil {
-				return stream.getReadBytes(), fmt.Errorf("failed to read array container: %s", err)
+				return stream.GetReadBytes(), fmt.Errorf("failed to read array container: %s", err)
 			}
 
 			nb := arrayContainer{
@@ -689,7 +679,7 @@ func (ra *roaringArray) readFrom(stream byteInput) (int64, error) {
 		}
 	}
 
-	return stream.getReadBytes(), nil
+	return stream.GetReadBytes(), nil
 }
 
 func (ra *roaringArray) hasRunCompression() bool {
@@ -702,84 +692,6 @@ func (ra *roaringArray) hasRunCompression() bool {
 	return false
 }
 
-func (ra *roaringArray) writeToMsgpack(stream io.Writer) error {
-
-	ra.conserz = make([]containerSerz, len(ra.containers))
-	for i, v := range ra.containers {
-		switch cn := v.(type) {
-		case *bitmapContainer:
-			bts, err := cn.MarshalMsg(nil)
-			if err != nil {
-				return err
-			}
-			ra.conserz[i].t = bitmapContype
-			ra.conserz[i].r = bts
-		case *arrayContainer:
-			bts, err := cn.MarshalMsg(nil)
-			if err != nil {
-				return err
-			}
-			ra.conserz[i].t = arrayContype
-			ra.conserz[i].r = bts
-		case *runContainer16:
-			bts, err := cn.MarshalMsg(nil)
-			if err != nil {
-				return err
-			}
-			ra.conserz[i].t = run16Contype
-			ra.conserz[i].r = bts
-		default:
-			panic(fmt.Errorf("Unrecognized container implementation: %T", cn))
-		}
-	}
-	w := snappy.NewWriter(stream)
-	err := msgp.Encode(w, ra)
-	ra.conserz = nil
-	return err
-}
-
-func (ra *roaringArray) readFromMsgpack(stream io.Reader) error {
-	r := snappy.NewReader(stream)
-	err := msgp.Decode(r, ra)
-	if err != nil {
-		return err
-	}
-
-	if len(ra.containers) != len(ra.keys) {
-		ra.containers = make([]container, len(ra.keys))
-	}
-
-	for i, v := range ra.conserz {
-		switch v.t {
-		case bitmapContype:
-			c := &bitmapContainer{}
-			_, err = c.UnmarshalMsg(v.r)
-			if err != nil {
-				return err
-			}
-			ra.containers[i] = c
-		case arrayContype:
-			c := &arrayContainer{}
-			_, err = c.UnmarshalMsg(v.r)
-			if err != nil {
-				return err
-			}
-			ra.containers[i] = c
-		case run16Contype:
-			c := &runContainer16{}
-			_, err = c.UnmarshalMsg(v.r)
-			if err != nil {
-				return err
-			}
-			ra.containers[i] = c
-		default:
-			return fmt.Errorf("unrecognized contype serialization code: '%v'", v.t)
-		}
-	}
-	ra.conserz = nil
-	return nil
-}
-
 func (ra *roaringArray) advanceUntil(min uint16, pos int) int {
 	lower := pos + 1
 
diff --git a/vendor/github.com/RoaringBitmap/roaring/roaringarray_gen.go b/vendor/github.com/RoaringBitmap/roaring/roaringarray_gen.go
deleted file mode 100644
index dcd718756a..0000000000
--- a/vendor/github.com/RoaringBitmap/roaring/roaringarray_gen.go
+++ /dev/null
@@ -1,529 +0,0 @@
-package roaring
-
-// NOTE: THIS FILE WAS PRODUCED BY THE
-// MSGP CODE GENERATION TOOL (github.com/tinylib/msgp)
-// DO NOT EDIT
-
-import (
-	"github.com/tinylib/msgp/msgp"
-)
-
-// Deprecated: DecodeMsg implements msgp.Decodable
-func (z *containerSerz) DecodeMsg(dc *msgp.Reader) (err error) {
-	var field []byte
-	_ = field
-	var zxvk uint32
-	zxvk, err = dc.ReadMapHeader()
-	if err != nil {
-		return
-	}
-	for zxvk > 0 {
-		zxvk--
-		field, err = dc.ReadMapKeyPtr()
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "t":
-			{
-				var zbzg uint8
-				zbzg, err = dc.ReadUint8()
-				z.t = contype(zbzg)
-			}
-			if err != nil {
-				return
-			}
-		case "r":
-			err = z.r.DecodeMsg(dc)
-			if err != nil {
-				return
-			}
-		default:
-			err = dc.Skip()
-			if err != nil {
-				return
-			}
-		}
-	}
-	return
-}
-
-// Deprecated: EncodeMsg implements msgp.Encodable
-func (z *containerSerz) EncodeMsg(en *msgp.Writer) (err error) {
-	// map header, size 2
-	// write "t"
-	err = en.Append(0x82, 0xa1, 0x74)
-	if err != nil {
-		return err
-	}
-	err = en.WriteUint8(uint8(z.t))
-	if err != nil {
-		return
-	}
-	// write "r"
-	err = en.Append(0xa1, 0x72)
-	if err != nil {
-		return err
-	}
-	err = z.r.EncodeMsg(en)
-	if err != nil {
-		return
-	}
-	return
-}
-
-// Deprecated: MarshalMsg implements msgp.Marshaler
-func (z *containerSerz) MarshalMsg(b []byte) (o []byte, err error) {
-	o = msgp.Require(b, z.Msgsize())
-	// map header, size 2
-	// string "t"
-	o = append(o, 0x82, 0xa1, 0x74)
-	o = msgp.AppendUint8(o, uint8(z.t))
-	// string "r"
-	o = append(o, 0xa1, 0x72)
-	o, err = z.r.MarshalMsg(o)
-	if err != nil {
-		return
-	}
-	return
-}
-
-// Deprecated: UnmarshalMsg implements msgp.Unmarshaler
-func (z *containerSerz) UnmarshalMsg(bts []byte) (o []byte, err error) {
-	var field []byte
-	_ = field
-	var zbai uint32
-	zbai, bts, err = msgp.ReadMapHeaderBytes(bts)
-	if err != nil {
-		return
-	}
-	for zbai > 0 {
-		zbai--
-		field, bts, err = msgp.ReadMapKeyZC(bts)
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "t":
-			{
-				var zcmr uint8
-				zcmr, bts, err = msgp.ReadUint8Bytes(bts)
-				z.t = contype(zcmr)
-			}
-			if err != nil {
-				return
-			}
-		case "r":
-			bts, err = z.r.UnmarshalMsg(bts)
-			if err != nil {
-				return
-			}
-		default:
-			bts, err = msgp.Skip(bts)
-			if err != nil {
-				return
-			}
-		}
-	}
-	o = bts
-	return
-}
-
-// Deprecated: Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
-func (z *containerSerz) Msgsize() (s int) {
-	s = 1 + 2 + msgp.Uint8Size + 2 + z.r.Msgsize()
-	return
-}
-
-// Deprecated: DecodeMsg implements msgp.Decodable
-func (z *contype) DecodeMsg(dc *msgp.Reader) (err error) {
-	{
-		var zajw uint8
-		zajw, err = dc.ReadUint8()
-		(*z) = contype(zajw)
-	}
-	if err != nil {
-		return
-	}
-	return
-}
-
-// Deprecated: EncodeMsg implements msgp.Encodable
-func (z contype) EncodeMsg(en *msgp.Writer) (err error) {
-	err = en.WriteUint8(uint8(z))
-	if err != nil {
-		return
-	}
-	return
-}
-
-// Deprecated: MarshalMsg implements msgp.Marshaler
-func (z contype) MarshalMsg(b []byte) (o []byte, err error) {
-	o = msgp.Require(b, z.Msgsize())
-	o = msgp.AppendUint8(o, uint8(z))
-	return
-}
-
-// Deprecated: UnmarshalMsg implements msgp.Unmarshaler
-func (z *contype) UnmarshalMsg(bts []byte) (o []byte, err error) {
-	{
-		var zwht uint8
-		zwht, bts, err = msgp.ReadUint8Bytes(bts)
-		(*z) = contype(zwht)
-	}
-	if err != nil {
-		return
-	}
-	o = bts
-	return
-}
-
-// Deprecated: Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
-func (z contype) Msgsize() (s int) {
-	s = msgp.Uint8Size
-	return
-}
-
-// Deprecated: DecodeMsg implements msgp.Decodable
-func (z *roaringArray) DecodeMsg(dc *msgp.Reader) (err error) {
-	var field []byte
-	_ = field
-	var zlqf uint32
-	zlqf, err = dc.ReadMapHeader()
-	if err != nil {
-		return
-	}
-	for zlqf > 0 {
-		zlqf--
-		field, err = dc.ReadMapKeyPtr()
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "keys":
-			var zdaf uint32
-			zdaf, err = dc.ReadArrayHeader()
-			if err != nil {
-				return
-			}
-			if cap(z.keys) >= int(zdaf) {
-				z.keys = (z.keys)[:zdaf]
-			} else {
-				z.keys = make([]uint16, zdaf)
-			}
-			for zhct := range z.keys {
-				z.keys[zhct], err = dc.ReadUint16()
-				if err != nil {
-					return
-				}
-			}
-		case "needCopyOnWrite":
-			var zpks uint32
-			zpks, err = dc.ReadArrayHeader()
-			if err != nil {
-				return
-			}
-			if cap(z.needCopyOnWrite) >= int(zpks) {
-				z.needCopyOnWrite = (z.needCopyOnWrite)[:zpks]
-			} else {
-				z.needCopyOnWrite = make([]bool, zpks)
-			}
-			for zcua := range z.needCopyOnWrite {
-				z.needCopyOnWrite[zcua], err = dc.ReadBool()
-				if err != nil {
-					return
-				}
-			}
-		case "copyOnWrite":
-			z.copyOnWrite, err = dc.ReadBool()
-			if err != nil {
-				return
-			}
-		case "conserz":
-			var zjfb uint32
-			zjfb, err = dc.ReadArrayHeader()
-			if err != nil {
-				return
-			}
-			if cap(z.conserz) >= int(zjfb) {
-				z.conserz = (z.conserz)[:zjfb]
-			} else {
-				z.conserz = make([]containerSerz, zjfb)
-			}
-			for zxhx := range z.conserz {
-				var zcxo uint32
-				zcxo, err = dc.ReadMapHeader()
-				if err != nil {
-					return
-				}
-				for zcxo > 0 {
-					zcxo--
-					field, err = dc.ReadMapKeyPtr()
-					if err != nil {
-						return
-					}
-					switch msgp.UnsafeString(field) {
-					case "t":
-						{
-							var zeff uint8
-							zeff, err = dc.ReadUint8()
-							z.conserz[zxhx].t = contype(zeff)
-						}
-						if err != nil {
-							return
-						}
-					case "r":
-						err = z.conserz[zxhx].r.DecodeMsg(dc)
-						if err != nil {
-							return
-						}
-					default:
-						err = dc.Skip()
-						if err != nil {
-							return
-						}
-					}
-				}
-			}
-		default:
-			err = dc.Skip()
-			if err != nil {
-				return
-			}
-		}
-	}
-	return
-}
-
-// Deprecated: EncodeMsg implements msgp.Encodable
-func (z *roaringArray) EncodeMsg(en *msgp.Writer) (err error) {
-	// map header, size 4
-	// write "keys"
-	err = en.Append(0x84, 0xa4, 0x6b, 0x65, 0x79, 0x73)
-	if err != nil {
-		return err
-	}
-	err = en.WriteArrayHeader(uint32(len(z.keys)))
-	if err != nil {
-		return
-	}
-	for zhct := range z.keys {
-		err = en.WriteUint16(z.keys[zhct])
-		if err != nil {
-			return
-		}
-	}
-	// write "needCopyOnWrite"
-	err = en.Append(0xaf, 0x6e, 0x65, 0x65, 0x64, 0x43, 0x6f, 0x70, 0x79, 0x4f, 0x6e, 0x57, 0x72, 0x69, 0x74, 0x65)
-	if err != nil {
-		return err
-	}
-	err = en.WriteArrayHeader(uint32(len(z.needCopyOnWrite)))
-	if err != nil {
-		return
-	}
-	for zcua := range z.needCopyOnWrite {
-		err = en.WriteBool(z.needCopyOnWrite[zcua])
-		if err != nil {
-			return
-		}
-	}
-	// write "copyOnWrite"
-	err = en.Append(0xab, 0x63, 0x6f, 0x70, 0x79, 0x4f, 0x6e, 0x57, 0x72, 0x69, 0x74, 0x65)
-	if err != nil {
-		return err
-	}
-	err = en.WriteBool(z.copyOnWrite)
-	if err != nil {
-		return
-	}
-	// write "conserz"
-	err = en.Append(0xa7, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x72, 0x7a)
-	if err != nil {
-		return err
-	}
-	err = en.WriteArrayHeader(uint32(len(z.conserz)))
-	if err != nil {
-		return
-	}
-	for zxhx := range z.conserz {
-		// map header, size 2
-		// write "t"
-		err = en.Append(0x82, 0xa1, 0x74)
-		if err != nil {
-			return err
-		}
-		err = en.WriteUint8(uint8(z.conserz[zxhx].t))
-		if err != nil {
-			return
-		}
-		// write "r"
-		err = en.Append(0xa1, 0x72)
-		if err != nil {
-			return err
-		}
-		err = z.conserz[zxhx].r.EncodeMsg(en)
-		if err != nil {
-			return
-		}
-	}
-	return
-}
-
-// Deprecated: MarshalMsg implements msgp.Marshaler
-func (z *roaringArray) MarshalMsg(b []byte) (o []byte, err error) {
-	o = msgp.Require(b, z.Msgsize())
-	// map header, size 4
-	// string "keys"
-	o = append(o, 0x84, 0xa4, 0x6b, 0x65, 0x79, 0x73)
-	o = msgp.AppendArrayHeader(o, uint32(len(z.keys)))
-	for zhct := range z.keys {
-		o = msgp.AppendUint16(o, z.keys[zhct])
-	}
-	// string "needCopyOnWrite"
-	o = append(o, 0xaf, 0x6e, 0x65, 0x65, 0x64, 0x43, 0x6f, 0x70, 0x79, 0x4f, 0x6e, 0x57, 0x72, 0x69, 0x74, 0x65)
-	o = msgp.AppendArrayHeader(o, uint32(len(z.needCopyOnWrite)))
-	for zcua := range z.needCopyOnWrite {
-		o = msgp.AppendBool(o, z.needCopyOnWrite[zcua])
-	}
-	// string "copyOnWrite"
-	o = append(o, 0xab, 0x63, 0x6f, 0x70, 0x79, 0x4f, 0x6e, 0x57, 0x72, 0x69, 0x74, 0x65)
-	o = msgp.AppendBool(o, z.copyOnWrite)
-	// string "conserz"
-	o = append(o, 0xa7, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x72, 0x7a)
-	o = msgp.AppendArrayHeader(o, uint32(len(z.conserz)))
-	for zxhx := range z.conserz {
-		// map header, size 2
-		// string "t"
-		o = append(o, 0x82, 0xa1, 0x74)
-		o = msgp.AppendUint8(o, uint8(z.conserz[zxhx].t))
-		// string "r"
-		o = append(o, 0xa1, 0x72)
-		o, err = z.conserz[zxhx].r.MarshalMsg(o)
-		if err != nil {
-			return
-		}
-	}
-	return
-}
-
-// Deprecated: UnmarshalMsg implements msgp.Unmarshaler
-func (z *roaringArray) UnmarshalMsg(bts []byte) (o []byte, err error) {
-	var field []byte
-	_ = field
-	var zrsw uint32
-	zrsw, bts, err = msgp.ReadMapHeaderBytes(bts)
-	if err != nil {
-		return
-	}
-	for zrsw > 0 {
-		zrsw--
-		field, bts, err = msgp.ReadMapKeyZC(bts)
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "keys":
-			var zxpk uint32
-			zxpk, bts, err = msgp.ReadArrayHeaderBytes(bts)
-			if err != nil {
-				return
-			}
-			if cap(z.keys) >= int(zxpk) {
-				z.keys = (z.keys)[:zxpk]
-			} else {
-				z.keys = make([]uint16, zxpk)
-			}
-			for zhct := range z.keys {
-				z.keys[zhct], bts, err = msgp.ReadUint16Bytes(bts)
-				if err != nil {
-					return
-				}
-			}
-		case "needCopyOnWrite":
-			var zdnj uint32
-			zdnj, bts, err = msgp.ReadArrayHeaderBytes(bts)
-			if err != nil {
-				return
-			}
-			if cap(z.needCopyOnWrite) >= int(zdnj) {
-				z.needCopyOnWrite = (z.needCopyOnWrite)[:zdnj]
-			} else {
-				z.needCopyOnWrite = make([]bool, zdnj)
-			}
-			for zcua := range z.needCopyOnWrite {
-				z.needCopyOnWrite[zcua], bts, err = msgp.ReadBoolBytes(bts)
-				if err != nil {
-					return
-				}
-			}
-		case "copyOnWrite":
-			z.copyOnWrite, bts, err = msgp.ReadBoolBytes(bts)
-			if err != nil {
-				return
-			}
-		case "conserz":
-			var zobc uint32
-			zobc, bts, err = msgp.ReadArrayHeaderBytes(bts)
-			if err != nil {
-				return
-			}
-			if cap(z.conserz) >= int(zobc) {
-				z.conserz = (z.conserz)[:zobc]
-			} else {
-				z.conserz = make([]containerSerz, zobc)
-			}
-			for zxhx := range z.conserz {
-				var zsnv uint32
-				zsnv, bts, err = msgp.ReadMapHeaderBytes(bts)
-				if err != nil {
-					return
-				}
-				for zsnv > 0 {
-					zsnv--
-					field, bts, err = msgp.ReadMapKeyZC(bts)
-					if err != nil {
-						return
-					}
-					switch msgp.UnsafeString(field) {
-					case "t":
-						{
-							var zkgt uint8
-							zkgt, bts, err = msgp.ReadUint8Bytes(bts)
-							z.conserz[zxhx].t = contype(zkgt)
-						}
-						if err != nil {
-							return
-						}
-					case "r":
-						bts, err = z.conserz[zxhx].r.UnmarshalMsg(bts)
-						if err != nil {
-							return
-						}
-					default:
-						bts, err = msgp.Skip(bts)
-						if err != nil {
-							return
-						}
-					}
-				}
-			}
-		default:
-			bts, err = msgp.Skip(bts)
-			if err != nil {
-				return
-			}
-		}
-	}
-	o = bts
-	return
-}
-
-// Deprecated: Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
-func (z *roaringArray) Msgsize() (s int) {
-	s = 1 + 5 + msgp.ArrayHeaderSize + (len(z.keys) * (msgp.Uint16Size)) + 16 + msgp.ArrayHeaderSize + (len(z.needCopyOnWrite) * (msgp.BoolSize)) + 12 + msgp.BoolSize + 8 + msgp.ArrayHeaderSize
-	for zxhx := range z.conserz {
-		s += 1 + 2 + msgp.Uint8Size + 2 + z.conserz[zxhx].r.Msgsize()
-	}
-	return
-}
diff --git a/vendor/github.com/RoaringBitmap/roaring/runcontainer.go b/vendor/github.com/RoaringBitmap/roaring/runcontainer.go
index fc1f456fbf..97c0036589 100644
--- a/vendor/github.com/RoaringBitmap/roaring/runcontainer.go
+++ b/vendor/github.com/RoaringBitmap/roaring/runcontainer.go
@@ -44,16 +44,11 @@ import (
 	"unsafe"
 )
 
-//go:generate msgp -unexported
-
 // runContainer16 does run-length encoding of sets of
 // uint16 integers.
 type runContainer16 struct {
 	iv   []interval16
 	card int64
-
-	// avoid allocation during search
-	myOpts searchOptions `msg:"-"`
 }
 
 // interval16 is the internal to runContainer16
@@ -120,8 +115,6 @@ func (p uint16Slice) Less(i, j int) bool { return p[i] < p[j] }
 // Swap swaps elements i and j.
 func (p uint16Slice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
 
-//msgp:ignore addHelper
-
 // addHelper helps build a runContainer16.
 type addHelper16 struct {
 	runstart      uint16
@@ -617,10 +610,7 @@ func (rc *runContainer16) unionCardinality(b *runContainer16) uint64 {
 
 // indexOfIntervalAtOrAfter is a helper for union.
 func (rc *runContainer16) indexOfIntervalAtOrAfter(key int64, startIndex int64) int64 {
-	rc.myOpts.startIndex = startIndex
-	rc.myOpts.endxIndex = 0
-
-	w, already, _ := rc.search(key, &rc.myOpts)
+	w, already, _ := rc.searchRange(key, startIndex, 0)
 	if already {
 		return w
 	}
@@ -844,7 +834,7 @@ toploop:
 
 // get returns true iff key is in the container.
 func (rc *runContainer16) contains(key uint16) bool {
-	_, in, _ := rc.search(int64(key), nil)
+	_, in, _ := rc.search(int64(key))
 	return in
 }
 
@@ -853,22 +843,7 @@ func (rc *runContainer16) numIntervals() int {
 	return len(rc.iv)
 }
 
-// searchOptions allows us to accelerate search with
-// prior knowledge of (mostly lower) bounds. This is used by Union
-// and Intersect.
-type searchOptions struct {
-	// start here instead of at 0
-	startIndex int64
-
-	// upper bound instead of len(rc.iv);
-	// endxIndex == 0 means ignore the bound and use
-	// endxIndex == n ==len(rc.iv) which is also
-	// naturally the default for search()
-	// when opt = nil.
-	endxIndex int64
-}
-
-// search returns alreadyPresent to indicate if the
+// searchRange returns alreadyPresent to indicate if the
 // key is already in one of our interval16s.
 //
 // If key is alreadyPresent, then whichInterval16 tells
@@ -892,24 +867,16 @@ type searchOptions struct {
 //
 // runContainer16.search always returns whichInterval16 < len(rc.iv).
 //
-// If not nil, opts can be used to further restrict
-// the search space.
+// The search space is from startIndex to endxIndex. If endxIndex is set to zero, then there 
+// no upper bound.
 //
-func (rc *runContainer16) search(key int64, opts *searchOptions) (whichInterval16 int64, alreadyPresent bool, numCompares int) {
+func (rc *runContainer16) searchRange(key int64, startIndex int64, endxIndex int64) (whichInterval16 int64, alreadyPresent bool, numCompares int) {
 	n := int64(len(rc.iv))
 	if n == 0 {
 		return -1, false, 0
 	}
-
-	startIndex := int64(0)
-	endxIndex := n
-	if opts != nil {
-		startIndex = opts.startIndex
-
-		// let endxIndex == 0 mean no effect
-		if opts.endxIndex > 0 {
-			endxIndex = opts.endxIndex
-		}
+	if endxIndex == 0 {
+		endxIndex = n
 	}
 
 	// sort.Search returns the smallest index i
@@ -979,6 +946,34 @@ func (rc *runContainer16) search(key int64, opts *searchOptions) (whichInterval1
 	return
 }
 
+// search returns alreadyPresent to indicate if the
+// key is already in one of our interval16s.
+//
+// If key is alreadyPresent, then whichInterval16 tells
+// you where.
+//
+// If key is not already present, then whichInterval16 is
+// set as follows:
+//
+//  a) whichInterval16 == len(rc.iv)-1 if key is beyond our
+//     last interval16 in rc.iv;
+//
+//  b) whichInterval16 == -1 if key is before our first
+//     interval16 in rc.iv;
+//
+//  c) whichInterval16 is set to the minimum index of rc.iv
+//     which comes strictly before the key;
+//     so  rc.iv[whichInterval16].last < key,
+//     and  if whichInterval16+1 exists, then key < rc.iv[whichInterval16+1].start
+//     (Note that whichInterval16+1 won't exist when
+//     whichInterval16 is the last interval.)
+//
+// runContainer16.search always returns whichInterval16 < len(rc.iv).
+//
+func (rc *runContainer16) search(key int64) (whichInterval16 int64, alreadyPresent bool, numCompares int) {
+	return rc.searchRange(key, 0, 0)
+}
+
 // cardinality returns the count of the integers stored in the
 // runContainer16.
 func (rc *runContainer16) cardinality() int64 {
@@ -1072,7 +1067,7 @@ func (rc *runContainer16) Add(k uint16) (wasNew bool) {
 
 	k64 := int64(k)
 
-	index, present, _ := rc.search(k64, nil)
+	index, present, _ := rc.search(k64)
 	if present {
 		return // already there
 	}
@@ -1147,8 +1142,6 @@ func (rc *runContainer16) Add(k uint16) (wasNew bool) {
 	return
 }
 
-//msgp:ignore runIterator
-
 // runIterator16 advice: you must call hasNext()
 // before calling next()/peekNext() to insure there are contents.
 type runIterator16 struct {
@@ -1207,13 +1200,8 @@ func (ri *runIterator16) advanceIfNeeded(minval uint16) {
 		return
 	}
 
-	opt := &searchOptions{
-		startIndex: ri.curIndex,
-		endxIndex:  int64(len(ri.rc.iv)),
-	}
-
 	// interval cannot be -1 because of minval > peekNext
-	interval, isPresent, _ := ri.rc.search(int64(minval), opt)
+	interval, isPresent, _ := ri.rc.searchRange(int64(minval), ri.curIndex, int64(len(ri.rc.iv)))
 
 	// if the minval is present, set the curPosIndex at the right position
 	if isPresent {
@@ -1366,7 +1354,7 @@ func (ri *runIterator16) nextMany64(hs uint64, buf []uint64) int {
 func (rc *runContainer16) removeKey(key uint16) (wasPresent bool) {
 
 	var index int64
-	index, wasPresent, _ = rc.search(int64(key), nil)
+	index, wasPresent, _ = rc.search(int64(key))
 	if !wasPresent {
 		return // already removed, nothing to do.
 	}
@@ -1457,12 +1445,8 @@ func intersectWithLeftover16(astart, alast, bstart, blast int64) (isOverlap, isL
 	return
 }
 
-func (rc *runContainer16) findNextIntervalThatIntersectsStartingFrom(startIndex int64, key int64) (index int64, done bool) {
-
-	rc.myOpts.startIndex = startIndex
-	rc.myOpts.endxIndex = 0
-
-	w, _, _ := rc.search(key, &rc.myOpts)
+func (rc *runContainer16) findNextIntervalThatIntersectsStartingFrom(startIndex int64, key int64) (index int64, done bool) {	
+	w, _, _ := rc.searchRange(key, startIndex, 0)
 	// rc.search always returns w < len(rc.iv)
 	if w < startIndex {
 		// not found and comes before lower bound startIndex,
@@ -1603,8 +1587,8 @@ func (rc *runContainer16) isubtract(del interval16) {
 	}
 
 	// INVAR there is some intersection between rc and del
-	istart, startAlready, _ := rc.search(int64(del.start), nil)
-	ilast, lastAlready, _ := rc.search(int64(del.last()), nil)
+	istart, startAlready, _ := rc.search(int64(del.start))
+	ilast, lastAlready, _ := rc.search(int64(del.last()))
 	rc.card = -1
 	if istart == -1 {
 		if ilast == n-1 && !lastAlready {
@@ -2356,7 +2340,7 @@ func (rc *runContainer16) getCardinality() int {
 func (rc *runContainer16) rank(x uint16) int {
 	n := int64(len(rc.iv))
 	xx := int64(x)
-	w, already, _ := rc.search(xx, nil)
+	w, already, _ := rc.search(xx)
 	if w < 0 {
 		return 0
 	}
diff --git a/vendor/github.com/RoaringBitmap/roaring/runcontainer_gen.go b/vendor/github.com/RoaringBitmap/roaring/runcontainer_gen.go
deleted file mode 100644
index 84537d087f..0000000000
--- a/vendor/github.com/RoaringBitmap/roaring/runcontainer_gen.go
+++ /dev/null
@@ -1,1104 +0,0 @@
-package roaring
-
-// NOTE: THIS FILE WAS PRODUCED BY THE
-// MSGP CODE GENERATION TOOL (github.com/tinylib/msgp)
-// DO NOT EDIT
-
-import "github.com/tinylib/msgp/msgp"
-
-// Deprecated: DecodeMsg implements msgp.Decodable
-func (z *addHelper16) DecodeMsg(dc *msgp.Reader) (err error) {
-	var field []byte
-	_ = field
-	var zbai uint32
-	zbai, err = dc.ReadMapHeader()
-	if err != nil {
-		return
-	}
-	for zbai > 0 {
-		zbai--
-		field, err = dc.ReadMapKeyPtr()
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "runstart":
-			z.runstart, err = dc.ReadUint16()
-			if err != nil {
-				return
-			}
-		case "runlen":
-			z.runlen, err = dc.ReadUint16()
-			if err != nil {
-				return
-			}
-		case "actuallyAdded":
-			z.actuallyAdded, err = dc.ReadUint16()
-			if err != nil {
-				return
-			}
-		case "m":
-			var zcmr uint32
-			zcmr, err = dc.ReadArrayHeader()
-			if err != nil {
-				return
-			}
-			if cap(z.m) >= int(zcmr) {
-				z.m = (z.m)[:zcmr]
-			} else {
-				z.m = make([]interval16, zcmr)
-			}
-			for zxvk := range z.m {
-				var zajw uint32
-				zajw, err = dc.ReadMapHeader()
-				if err != nil {
-					return
-				}
-				for zajw > 0 {
-					zajw--
-					field, err = dc.ReadMapKeyPtr()
-					if err != nil {
-						return
-					}
-					switch msgp.UnsafeString(field) {
-					case "start":
-						z.m[zxvk].start, err = dc.ReadUint16()
-						if err != nil {
-							return
-						}
-					case "last":
-						z.m[zxvk].length, err = dc.ReadUint16()
-						z.m[zxvk].length -= z.m[zxvk].start
-						if err != nil {
-							return
-						}
-					default:
-						err = dc.Skip()
-						if err != nil {
-							return
-						}
-					}
-				}
-			}
-		case "rc":
-			if dc.IsNil() {
-				err = dc.ReadNil()
-				if err != nil {
-					return
-				}
-				z.rc = nil
-			} else {
-				if z.rc == nil {
-					z.rc = new(runContainer16)
-				}
-				var zwht uint32
-				zwht, err = dc.ReadMapHeader()
-				if err != nil {
-					return
-				}
-				for zwht > 0 {
-					zwht--
-					field, err = dc.ReadMapKeyPtr()
-					if err != nil {
-						return
-					}
-					switch msgp.UnsafeString(field) {
-					case "iv":
-						var zhct uint32
-						zhct, err = dc.ReadArrayHeader()
-						if err != nil {
-							return
-						}
-						if cap(z.rc.iv) >= int(zhct) {
-							z.rc.iv = (z.rc.iv)[:zhct]
-						} else {
-							z.rc.iv = make([]interval16, zhct)
-						}
-						for zbzg := range z.rc.iv {
-							var zcua uint32
-							zcua, err = dc.ReadMapHeader()
-							if err != nil {
-								return
-							}
-							for zcua > 0 {
-								zcua--
-								field, err = dc.ReadMapKeyPtr()
-								if err != nil {
-									return
-								}
-								switch msgp.UnsafeString(field) {
-								case "start":
-									z.rc.iv[zbzg].start, err = dc.ReadUint16()
-									if err != nil {
-										return
-									}
-								case "last":
-									z.rc.iv[zbzg].length, err = dc.ReadUint16()
-									z.rc.iv[zbzg].length -= z.rc.iv[zbzg].start
-									if err != nil {
-										return
-									}
-								default:
-									err = dc.Skip()
-									if err != nil {
-										return
-									}
-								}
-							}
-						}
-					case "card":
-						z.rc.card, err = dc.ReadInt64()
-						if err != nil {
-							return
-						}
-					default:
-						err = dc.Skip()
-						if err != nil {
-							return
-						}
-					}
-				}
-			}
-		default:
-			err = dc.Skip()
-			if err != nil {
-				return
-			}
-		}
-	}
-	return
-}
-
-// Deprecated: EncodeMsg implements msgp.Encodable
-func (z *addHelper16) EncodeMsg(en *msgp.Writer) (err error) {
-	// map header, size 5
-	// write "runstart"
-	err = en.Append(0x85, 0xa8, 0x72, 0x75, 0x6e, 0x73, 0x74, 0x61, 0x72, 0x74)
-	if err != nil {
-		return err
-	}
-	err = en.WriteUint16(z.runstart)
-	if err != nil {
-		return
-	}
-	// write "runlen"
-	err = en.Append(0xa6, 0x72, 0x75, 0x6e, 0x6c, 0x65, 0x6e)
-	if err != nil {
-		return err
-	}
-	err = en.WriteUint16(z.runlen)
-	if err != nil {
-		return
-	}
-	// write "actuallyAdded"
-	err = en.Append(0xad, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x41, 0x64, 0x64, 0x65, 0x64)
-	if err != nil {
-		return err
-	}
-	err = en.WriteUint16(z.actuallyAdded)
-	if err != nil {
-		return
-	}
-	// write "m"
-	err = en.Append(0xa1, 0x6d)
-	if err != nil {
-		return err
-	}
-	err = en.WriteArrayHeader(uint32(len(z.m)))
-	if err != nil {
-		return
-	}
-	for zxvk := range z.m {
-		// map header, size 2
-		// write "start"
-		err = en.Append(0x82, 0xa5, 0x73, 0x74, 0x61, 0x72, 0x74)
-		if err != nil {
-			return err
-		}
-		err = en.WriteUint16(z.m[zxvk].start)
-		if err != nil {
-			return
-		}
-		// write "last"
-		err = en.Append(0xa4, 0x6c, 0x61, 0x73, 0x74)
-		if err != nil {
-			return err
-		}
-		err = en.WriteUint16(z.m[zxvk].last())
-		if err != nil {
-			return
-		}
-	}
-	// write "rc"
-	err = en.Append(0xa2, 0x72, 0x63)
-	if err != nil {
-		return err
-	}
-	if z.rc == nil {
-		err = en.WriteNil()
-		if err != nil {
-			return
-		}
-	} else {
-		// map header, size 2
-		// write "iv"
-		err = en.Append(0x82, 0xa2, 0x69, 0x76)
-		if err != nil {
-			return err
-		}
-		err = en.WriteArrayHeader(uint32(len(z.rc.iv)))
-		if err != nil {
-			return
-		}
-		for zbzg := range z.rc.iv {
-			// map header, size 2
-			// write "start"
-			err = en.Append(0x82, 0xa5, 0x73, 0x74, 0x61, 0x72, 0x74)
-			if err != nil {
-				return err
-			}
-			err = en.WriteUint16(z.rc.iv[zbzg].start)
-			if err != nil {
-				return
-			}
-			// write "last"
-			err = en.Append(0xa4, 0x6c, 0x61, 0x73, 0x74)
-			if err != nil {
-				return err
-			}
-			err = en.WriteUint16(z.rc.iv[zbzg].last())
-			if err != nil {
-				return
-			}
-		}
-		// write "card"
-		err = en.Append(0xa4, 0x63, 0x61, 0x72, 0x64)
-		if err != nil {
-			return err
-		}
-		err = en.WriteInt64(z.rc.card)
-		if err != nil {
-			return
-		}
-	}
-	return
-}
-
-// Deprecated: MarshalMsg implements msgp.Marshaler
-func (z *addHelper16) MarshalMsg(b []byte) (o []byte, err error) {
-	o = msgp.Require(b, z.Msgsize())
-	// map header, size 5
-	// string "runstart"
-	o = append(o, 0x85, 0xa8, 0x72, 0x75, 0x6e, 0x73, 0x74, 0x61, 0x72, 0x74)
-	o = msgp.AppendUint16(o, z.runstart)
-	// string "runlen"
-	o = append(o, 0xa6, 0x72, 0x75, 0x6e, 0x6c, 0x65, 0x6e)
-	o = msgp.AppendUint16(o, z.runlen)
-	// string "actuallyAdded"
-	o = append(o, 0xad, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x41, 0x64, 0x64, 0x65, 0x64)
-	o = msgp.AppendUint16(o, z.actuallyAdded)
-	// string "m"
-	o = append(o, 0xa1, 0x6d)
-	o = msgp.AppendArrayHeader(o, uint32(len(z.m)))
-	for zxvk := range z.m {
-		// map header, size 2
-		// string "start"
-		o = append(o, 0x82, 0xa5, 0x73, 0x74, 0x61, 0x72, 0x74)
-		o = msgp.AppendUint16(o, z.m[zxvk].start)
-		// string "last"
-		o = append(o, 0xa4, 0x6c, 0x61, 0x73, 0x74)
-		o = msgp.AppendUint16(o, z.m[zxvk].last())
-	}
-	// string "rc"
-	o = append(o, 0xa2, 0x72, 0x63)
-	if z.rc == nil {
-		o = msgp.AppendNil(o)
-	} else {
-		// map header, size 2
-		// string "iv"
-		o = append(o, 0x82, 0xa2, 0x69, 0x76)
-		o = msgp.AppendArrayHeader(o, uint32(len(z.rc.iv)))
-		for zbzg := range z.rc.iv {
-			// map header, size 2
-			// string "start"
-			o = append(o, 0x82, 0xa5, 0x73, 0x74, 0x61, 0x72, 0x74)
-			o = msgp.AppendUint16(o, z.rc.iv[zbzg].start)
-			// string "last"
-			o = append(o, 0xa4, 0x6c, 0x61, 0x73, 0x74)
-			o = msgp.AppendUint16(o, z.rc.iv[zbzg].last())
-		}
-		// string "card"
-		o = append(o, 0xa4, 0x63, 0x61, 0x72, 0x64)
-		o = msgp.AppendInt64(o, z.rc.card)
-	}
-	return
-}
-
-// Deprecated: UnmarshalMsg implements msgp.Unmarshaler
-func (z *addHelper16) UnmarshalMsg(bts []byte) (o []byte, err error) {
-	var field []byte
-	_ = field
-	var zxhx uint32
-	zxhx, bts, err = msgp.ReadMapHeaderBytes(bts)
-	if err != nil {
-		return
-	}
-	for zxhx > 0 {
-		zxhx--
-		field, bts, err = msgp.ReadMapKeyZC(bts)
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "runstart":
-			z.runstart, bts, err = msgp.ReadUint16Bytes(bts)
-			if err != nil {
-				return
-			}
-		case "runlen":
-			z.runlen, bts, err = msgp.ReadUint16Bytes(bts)
-			if err != nil {
-				return
-			}
-		case "actuallyAdded":
-			z.actuallyAdded, bts, err = msgp.ReadUint16Bytes(bts)
-			if err != nil {
-				return
-			}
-		case "m":
-			var zlqf uint32
-			zlqf, bts, err = msgp.ReadArrayHeaderBytes(bts)
-			if err != nil {
-				return
-			}
-			if cap(z.m) >= int(zlqf) {
-				z.m = (z.m)[:zlqf]
-			} else {
-				z.m = make([]interval16, zlqf)
-			}
-			for zxvk := range z.m {
-				var zdaf uint32
-				zdaf, bts, err = msgp.ReadMapHeaderBytes(bts)
-				if err != nil {
-					return
-				}
-				for zdaf > 0 {
-					zdaf--
-					field, bts, err = msgp.ReadMapKeyZC(bts)
-					if err != nil {
-						return
-					}
-					switch msgp.UnsafeString(field) {
-					case "start":
-						z.m[zxvk].start, bts, err = msgp.ReadUint16Bytes(bts)
-						if err != nil {
-							return
-						}
-					case "last":
-						z.m[zxvk].length, bts, err = msgp.ReadUint16Bytes(bts)
-						z.m[zxvk].length -= z.m[zxvk].start
-						if err != nil {
-							return
-						}
-					default:
-						bts, err = msgp.Skip(bts)
-						if err != nil {
-							return
-						}
-					}
-				}
-			}
-		case "rc":
-			if msgp.IsNil(bts) {
-				bts, err = msgp.ReadNilBytes(bts)
-				if err != nil {
-					return
-				}
-				z.rc = nil
-			} else {
-				if z.rc == nil {
-					z.rc = new(runContainer16)
-				}
-				var zpks uint32
-				zpks, bts, err = msgp.ReadMapHeaderBytes(bts)
-				if err != nil {
-					return
-				}
-				for zpks > 0 {
-					zpks--
-					field, bts, err = msgp.ReadMapKeyZC(bts)
-					if err != nil {
-						return
-					}
-					switch msgp.UnsafeString(field) {
-					case "iv":
-						var zjfb uint32
-						zjfb, bts, err = msgp.ReadArrayHeaderBytes(bts)
-						if err != nil {
-							return
-						}
-						if cap(z.rc.iv) >= int(zjfb) {
-							z.rc.iv = (z.rc.iv)[:zjfb]
-						} else {
-							z.rc.iv = make([]interval16, zjfb)
-						}
-						for zbzg := range z.rc.iv {
-							var zcxo uint32
-							zcxo, bts, err = msgp.ReadMapHeaderBytes(bts)
-							if err != nil {
-								return
-							}
-							for zcxo > 0 {
-								zcxo--
-								field, bts, err = msgp.ReadMapKeyZC(bts)
-								if err != nil {
-									return
-								}
-								switch msgp.UnsafeString(field) {
-								case "start":
-									z.rc.iv[zbzg].start, bts, err = msgp.ReadUint16Bytes(bts)
-									if err != nil {
-										return
-									}
-								case "last":
-									z.rc.iv[zbzg].length, bts, err = msgp.ReadUint16Bytes(bts)
-									z.rc.iv[zbzg].length -= z.rc.iv[zbzg].start
-									if err != nil {
-										return
-									}
-								default:
-									bts, err = msgp.Skip(bts)
-									if err != nil {
-										return
-									}
-								}
-							}
-						}
-					case "card":
-						z.rc.card, bts, err = msgp.ReadInt64Bytes(bts)
-						if err != nil {
-							return
-						}
-					default:
-						bts, err = msgp.Skip(bts)
-						if err != nil {
-							return
-						}
-					}
-				}
-			}
-		default:
-			bts, err = msgp.Skip(bts)
-			if err != nil {
-				return
-			}
-		}
-	}
-	o = bts
-	return
-}
-
-// Deprecated: Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
-func (z *addHelper16) Msgsize() (s int) {
-	s = 1 + 9 + msgp.Uint16Size + 7 + msgp.Uint16Size + 14 + msgp.Uint16Size + 2 + msgp.ArrayHeaderSize + (len(z.m) * (12 + msgp.Uint16Size + msgp.Uint16Size)) + 3
-	if z.rc == nil {
-		s += msgp.NilSize
-	} else {
-		s += 1 + 3 + msgp.ArrayHeaderSize + (len(z.rc.iv) * (12 + msgp.Uint16Size + msgp.Uint16Size)) + 5 + msgp.Int64Size
-	}
-	return
-}
-
-// Deprecated: DecodeMsg implements msgp.Decodable
-func (z *interval16) DecodeMsg(dc *msgp.Reader) (err error) {
-	var field []byte
-	_ = field
-	var zeff uint32
-	zeff, err = dc.ReadMapHeader()
-	if err != nil {
-		return
-	}
-	for zeff > 0 {
-		zeff--
-		field, err = dc.ReadMapKeyPtr()
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "start":
-			z.start, err = dc.ReadUint16()
-			if err != nil {
-				return
-			}
-		case "last":
-			z.length, err = dc.ReadUint16()
-			z.length = -z.start
-			if err != nil {
-				return
-			}
-		default:
-			err = dc.Skip()
-			if err != nil {
-				return
-			}
-		}
-	}
-	return
-}
-
-// Deprecated: EncodeMsg implements msgp.Encodable
-func (z interval16) EncodeMsg(en *msgp.Writer) (err error) {
-	// map header, size 2
-	// write "start"
-	err = en.Append(0x82, 0xa5, 0x73, 0x74, 0x61, 0x72, 0x74)
-	if err != nil {
-		return err
-	}
-	err = en.WriteUint16(z.start)
-	if err != nil {
-		return
-	}
-	// write "last"
-	err = en.Append(0xa4, 0x6c, 0x61, 0x73, 0x74)
-	if err != nil {
-		return err
-	}
-	err = en.WriteUint16(z.last())
-	if err != nil {
-		return
-	}
-	return
-}
-
-// Deprecated: MarshalMsg implements msgp.Marshaler
-func (z interval16) MarshalMsg(b []byte) (o []byte, err error) {
-	o = msgp.Require(b, z.Msgsize())
-	// map header, size 2
-	// string "start"
-	o = append(o, 0x82, 0xa5, 0x73, 0x74, 0x61, 0x72, 0x74)
-	o = msgp.AppendUint16(o, z.start)
-	// string "last"
-	o = append(o, 0xa4, 0x6c, 0x61, 0x73, 0x74)
-	o = msgp.AppendUint16(o, z.last())
-	return
-}
-
-// Deprecated: UnmarshalMsg implements msgp.Unmarshaler
-func (z *interval16) UnmarshalMsg(bts []byte) (o []byte, err error) {
-	var field []byte
-	_ = field
-	var zrsw uint32
-	zrsw, bts, err = msgp.ReadMapHeaderBytes(bts)
-	if err != nil {
-		return
-	}
-	for zrsw > 0 {
-		zrsw--
-		field, bts, err = msgp.ReadMapKeyZC(bts)
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "start":
-			z.start, bts, err = msgp.ReadUint16Bytes(bts)
-			if err != nil {
-				return
-			}
-		case "last":
-			z.length, bts, err = msgp.ReadUint16Bytes(bts)
-			z.length -= z.start
-			if err != nil {
-				return
-			}
-		default:
-			bts, err = msgp.Skip(bts)
-			if err != nil {
-				return
-			}
-		}
-	}
-	o = bts
-	return
-}
-
-// Deprecated: Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
-func (z interval16) Msgsize() (s int) {
-	s = 1 + 6 + msgp.Uint16Size + 5 + msgp.Uint16Size
-	return
-}
-
-// Deprecated: DecodeMsg implements msgp.Decodable
-func (z *runContainer16) DecodeMsg(dc *msgp.Reader) (err error) {
-	var field []byte
-	_ = field
-	var zdnj uint32
-	zdnj, err = dc.ReadMapHeader()
-	if err != nil {
-		return
-	}
-	for zdnj > 0 {
-		zdnj--
-		field, err = dc.ReadMapKeyPtr()
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "iv":
-			var zobc uint32
-			zobc, err = dc.ReadArrayHeader()
-			if err != nil {
-				return
-			}
-			if cap(z.iv) >= int(zobc) {
-				z.iv = (z.iv)[:zobc]
-			} else {
-				z.iv = make([]interval16, zobc)
-			}
-			for zxpk := range z.iv {
-				var zsnv uint32
-				zsnv, err = dc.ReadMapHeader()
-				if err != nil {
-					return
-				}
-				for zsnv > 0 {
-					zsnv--
-					field, err = dc.ReadMapKeyPtr()
-					if err != nil {
-						return
-					}
-					switch msgp.UnsafeString(field) {
-					case "start":
-						z.iv[zxpk].start, err = dc.ReadUint16()
-						if err != nil {
-							return
-						}
-					case "last":
-						z.iv[zxpk].length, err = dc.ReadUint16()
-						z.iv[zxpk].length -= z.iv[zxpk].start
-						if err != nil {
-							return
-						}
-					default:
-						err = dc.Skip()
-						if err != nil {
-							return
-						}
-					}
-				}
-			}
-		case "card":
-			z.card, err = dc.ReadInt64()
-			if err != nil {
-				return
-			}
-		default:
-			err = dc.Skip()
-			if err != nil {
-				return
-			}
-		}
-	}
-	return
-}
-
-// Deprecated: EncodeMsg implements msgp.Encodable
-func (z *runContainer16) EncodeMsg(en *msgp.Writer) (err error) {
-	// map header, size 2
-	// write "iv"
-	err = en.Append(0x82, 0xa2, 0x69, 0x76)
-	if err != nil {
-		return err
-	}
-	err = en.WriteArrayHeader(uint32(len(z.iv)))
-	if err != nil {
-		return
-	}
-	for zxpk := range z.iv {
-		// map header, size 2
-		// write "start"
-		err = en.Append(0x82, 0xa5, 0x73, 0x74, 0x61, 0x72, 0x74)
-		if err != nil {
-			return err
-		}
-		err = en.WriteUint16(z.iv[zxpk].start)
-		if err != nil {
-			return
-		}
-		// write "last"
-		err = en.Append(0xa4, 0x6c, 0x61, 0x73, 0x74)
-		if err != nil {
-			return err
-		}
-		err = en.WriteUint16(z.iv[zxpk].last())
-		if err != nil {
-			return
-		}
-	}
-	// write "card"
-	err = en.Append(0xa4, 0x63, 0x61, 0x72, 0x64)
-	if err != nil {
-		return err
-	}
-	err = en.WriteInt64(z.card)
-	if err != nil {
-		return
-	}
-	return
-}
-
-// Deprecated: MarshalMsg implements msgp.Marshaler
-func (z *runContainer16) MarshalMsg(b []byte) (o []byte, err error) {
-	o = msgp.Require(b, z.Msgsize())
-	// map header, size 2
-	// string "iv"
-	o = append(o, 0x82, 0xa2, 0x69, 0x76)
-	o = msgp.AppendArrayHeader(o, uint32(len(z.iv)))
-	for zxpk := range z.iv {
-		// map header, size 2
-		// string "start"
-		o = append(o, 0x82, 0xa5, 0x73, 0x74, 0x61, 0x72, 0x74)
-		o = msgp.AppendUint16(o, z.iv[zxpk].start)
-		// string "last"
-		o = append(o, 0xa4, 0x6c, 0x61, 0x73, 0x74)
-		o = msgp.AppendUint16(o, z.iv[zxpk].last())
-	}
-	// string "card"
-	o = append(o, 0xa4, 0x63, 0x61, 0x72, 0x64)
-	o = msgp.AppendInt64(o, z.card)
-	return
-}
-
-// Deprecated: UnmarshalMsg implements msgp.Unmarshaler
-func (z *runContainer16) UnmarshalMsg(bts []byte) (o []byte, err error) {
-	var field []byte
-	_ = field
-	var zkgt uint32
-	zkgt, bts, err = msgp.ReadMapHeaderBytes(bts)
-	if err != nil {
-		return
-	}
-	for zkgt > 0 {
-		zkgt--
-		field, bts, err = msgp.ReadMapKeyZC(bts)
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "iv":
-			var zema uint32
-			zema, bts, err = msgp.ReadArrayHeaderBytes(bts)
-			if err != nil {
-				return
-			}
-			if cap(z.iv) >= int(zema) {
-				z.iv = (z.iv)[:zema]
-			} else {
-				z.iv = make([]interval16, zema)
-			}
-			for zxpk := range z.iv {
-				var zpez uint32
-				zpez, bts, err = msgp.ReadMapHeaderBytes(bts)
-				if err != nil {
-					return
-				}
-				for zpez > 0 {
-					zpez--
-					field, bts, err = msgp.ReadMapKeyZC(bts)
-					if err != nil {
-						return
-					}
-					switch msgp.UnsafeString(field) {
-					case "start":
-						z.iv[zxpk].start, bts, err = msgp.ReadUint16Bytes(bts)
-						if err != nil {
-							return
-						}
-					case "last":
-						z.iv[zxpk].length, bts, err = msgp.ReadUint16Bytes(bts)
-						z.iv[zxpk].length -= z.iv[zxpk].start
-						if err != nil {
-							return
-						}
-					default:
-						bts, err = msgp.Skip(bts)
-						if err != nil {
-							return
-						}
-					}
-				}
-			}
-		case "card":
-			z.card, bts, err = msgp.ReadInt64Bytes(bts)
-			if err != nil {
-				return
-			}
-		default:
-			bts, err = msgp.Skip(bts)
-			if err != nil {
-				return
-			}
-		}
-	}
-	o = bts
-	return
-}
-
-// Deprecated: Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
-func (z *runContainer16) Msgsize() (s int) {
-	s = 1 + 3 + msgp.ArrayHeaderSize + (len(z.iv) * (12 + msgp.Uint16Size + msgp.Uint16Size)) + 5 + msgp.Int64Size
-	return
-}
-
-// Deprecated: DecodeMsg implements msgp.Decodable
-func (z *runIterator16) DecodeMsg(dc *msgp.Reader) (err error) {
-	var field []byte
-	_ = field
-	var zqke uint32
-	zqke, err = dc.ReadMapHeader()
-	if err != nil {
-		return
-	}
-	for zqke > 0 {
-		zqke--
-		field, err = dc.ReadMapKeyPtr()
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "rc":
-			if dc.IsNil() {
-				err = dc.ReadNil()
-				if err != nil {
-					return
-				}
-				z.rc = nil
-			} else {
-				if z.rc == nil {
-					z.rc = new(runContainer16)
-				}
-				err = z.rc.DecodeMsg(dc)
-				if err != nil {
-					return
-				}
-			}
-		case "curIndex":
-			z.curIndex, err = dc.ReadInt64()
-			if err != nil {
-				return
-			}
-		case "curPosInIndex":
-			z.curPosInIndex, err = dc.ReadUint16()
-			if err != nil {
-				return
-			}
-		default:
-			err = dc.Skip()
-			if err != nil {
-				return
-			}
-		}
-	}
-	return
-}
-
-// Deprecated: EncodeMsg implements msgp.Encodable
-func (z *runIterator16) EncodeMsg(en *msgp.Writer) (err error) {
-	// map header, size 3
-	// write "rc"
-	err = en.Append(0x83, 0xa2, 0x72, 0x63)
-	if err != nil {
-		return err
-	}
-	if z.rc == nil {
-		err = en.WriteNil()
-		if err != nil {
-			return
-		}
-	} else {
-		err = z.rc.EncodeMsg(en)
-		if err != nil {
-			return
-		}
-	}
-	// write "curIndex"
-	err = en.Append(0xa8, 0x63, 0x75, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78)
-	if err != nil {
-		return err
-	}
-	err = en.WriteInt64(z.curIndex)
-	if err != nil {
-		return
-	}
-	// write "curPosInIndex"
-	err = en.Append(0xad, 0x63, 0x75, 0x72, 0x50, 0x6f, 0x73, 0x49, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78)
-	if err != nil {
-		return err
-	}
-	err = en.WriteUint16(z.curPosInIndex)
-	if err != nil {
-		return
-	}
-	return
-}
-
-// Deprecated: MarshalMsg implements msgp.Marshaler
-func (z *runIterator16) MarshalMsg(b []byte) (o []byte, err error) {
-	o = msgp.Require(b, z.Msgsize())
-	// map header, size 3
-	// string "rc"
-	o = append(o, 0x83, 0xa2, 0x72, 0x63)
-	if z.rc == nil {
-		o = msgp.AppendNil(o)
-	} else {
-		o, err = z.rc.MarshalMsg(o)
-		if err != nil {
-			return
-		}
-	}
-	// string "curIndex"
-	o = append(o, 0xa8, 0x63, 0x75, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78)
-	o = msgp.AppendInt64(o, z.curIndex)
-	// string "curPosInIndex"
-	o = append(o, 0xad, 0x63, 0x75, 0x72, 0x50, 0x6f, 0x73, 0x49, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78)
-	o = msgp.AppendUint16(o, z.curPosInIndex)
-	return
-}
-
-// Deprecated: UnmarshalMsg implements msgp.Unmarshaler
-func (z *runIterator16) UnmarshalMsg(bts []byte) (o []byte, err error) {
-	var field []byte
-	_ = field
-	var zqyh uint32
-	zqyh, bts, err = msgp.ReadMapHeaderBytes(bts)
-	if err != nil {
-		return
-	}
-	for zqyh > 0 {
-		zqyh--
-		field, bts, err = msgp.ReadMapKeyZC(bts)
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "rc":
-			if msgp.IsNil(bts) {
-				bts, err = msgp.ReadNilBytes(bts)
-				if err != nil {
-					return
-				}
-				z.rc = nil
-			} else {
-				if z.rc == nil {
-					z.rc = new(runContainer16)
-				}
-				bts, err = z.rc.UnmarshalMsg(bts)
-				if err != nil {
-					return
-				}
-			}
-		case "curIndex":
-			z.curIndex, bts, err = msgp.ReadInt64Bytes(bts)
-			if err != nil {
-				return
-			}
-		case "curPosInIndex":
-			z.curPosInIndex, bts, err = msgp.ReadUint16Bytes(bts)
-			if err != nil {
-				return
-			}
-		default:
-			bts, err = msgp.Skip(bts)
-			if err != nil {
-				return
-			}
-		}
-	}
-	o = bts
-	return
-}
-
-// Deprecated: Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
-func (z *runIterator16) Msgsize() (s int) {
-	s = 1 + 3
-	if z.rc == nil {
-		s += msgp.NilSize
-	} else {
-		s += z.rc.Msgsize()
-	}
-	s += 9 + msgp.Int64Size + 14 + msgp.Uint16Size
-	return
-}
-
-// Deprecated: DecodeMsg implements msgp.Decodable
-func (z *uint16Slice) DecodeMsg(dc *msgp.Reader) (err error) {
-	var zjpj uint32
-	zjpj, err = dc.ReadArrayHeader()
-	if err != nil {
-		return
-	}
-	if cap((*z)) >= int(zjpj) {
-		(*z) = (*z)[:zjpj]
-	} else {
-		(*z) = make(uint16Slice, zjpj)
-	}
-	for zywj := range *z {
-		(*z)[zywj], err = dc.ReadUint16()
-		if err != nil {
-			return
-		}
-	}
-	return
-}
-
-// Deprecated: EncodeMsg implements msgp.Encodable
-func (z uint16Slice) EncodeMsg(en *msgp.Writer) (err error) {
-	err = en.WriteArrayHeader(uint32(len(z)))
-	if err != nil {
-		return
-	}
-	for zzpf := range z {
-		err = en.WriteUint16(z[zzpf])
-		if err != nil {
-			return
-		}
-	}
-	return
-}
-
-// Deprecated: MarshalMsg implements msgp.Marshaler
-func (z uint16Slice) MarshalMsg(b []byte) (o []byte, err error) {
-	o = msgp.Require(b, z.Msgsize())
-	o = msgp.AppendArrayHeader(o, uint32(len(z)))
-	for zzpf := range z {
-		o = msgp.AppendUint16(o, z[zzpf])
-	}
-	return
-}
-
-// Deprecated: UnmarshalMsg implements msgp.Unmarshaler
-func (z *uint16Slice) UnmarshalMsg(bts []byte) (o []byte, err error) {
-	var zgmo uint32
-	zgmo, bts, err = msgp.ReadArrayHeaderBytes(bts)
-	if err != nil {
-		return
-	}
-	if cap((*z)) >= int(zgmo) {
-		(*z) = (*z)[:zgmo]
-	} else {
-		(*z) = make(uint16Slice, zgmo)
-	}
-	for zrfe := range *z {
-		(*z)[zrfe], bts, err = msgp.ReadUint16Bytes(bts)
-		if err != nil {
-			return
-		}
-	}
-	o = bts
-	return
-}
-
-// Deprecated: Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
-func (z uint16Slice) Msgsize() (s int) {
-	s = msgp.ArrayHeaderSize + (len(z) * (msgp.Uint16Size))
-	return
-}
diff --git a/vendor/github.com/RoaringBitmap/roaring/serialization.go b/vendor/github.com/RoaringBitmap/roaring/serialization.go
index 7b7ed29b0a..70e3bbcc57 100644
--- a/vendor/github.com/RoaringBitmap/roaring/serialization.go
+++ b/vendor/github.com/RoaringBitmap/roaring/serialization.go
@@ -3,8 +3,6 @@ package roaring
 import (
 	"encoding/binary"
 	"io"
-
-	"github.com/tinylib/msgp/msgp"
 )
 
 // writeTo for runContainer16 follows this
@@ -19,16 +17,3 @@ func (b *runContainer16) writeTo(stream io.Writer) (int, error) {
 	}
 	return stream.Write(buf)
 }
-
-func (b *runContainer16) writeToMsgpack(stream io.Writer) (int, error) {
-	bts, err := b.MarshalMsg(nil)
-	if err != nil {
-		return 0, err
-	}
-	return stream.Write(bts)
-}
-
-func (b *runContainer16) readFromMsgpack(stream io.Reader) (int, error) {
-	err := msgp.Decode(stream, b)
-	return 0, err
-}