diff --git a/roaring/roaring.go b/roaring/roaring.go
index fc01b3783..b19e9934e 100644
--- a/roaring/roaring.go
+++ b/roaring/roaring.go
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// package roaring implements roaring bitmaps with support for incremental changes.
+// Package roaring implements roaring bitmaps with support for incremental changes.
 package roaring
 
 import (
@@ -50,11 +50,15 @@ const (
 	// bitmapN is the number of values in a container.bitmap.
 	bitmapN = (1 << 16) / 64
 
-	// manual allocation size tuned to our average client data
-	manualAlloc     = 524288
-	ContainerArray  = byte(1)
+	//ContainerArray indicates a container of bit position values
+	ContainerArray = byte(1)
+
+	//ContainerBitmap indicates a container of bits packed in a uint64 array block
 	ContainerBitmap = byte(2)
-	ContainerRun    = byte(3)
+
+	//ContainerRun  indicates a container of run encoded bits
+	ContainerRun = byte(3)
+
 	maxContainerVal = 0xffff
 )
 
@@ -216,7 +220,7 @@ func (b *Bitmap) CountRange(start, end uint64) (n uint64) {
 	} else {
 		// Count first partial container and advance i so we don't recount it
 		n += uint64(b.containers[i].countRange(int(lowbits(start)), maxContainerVal+1))
-		i += 1
+		i++
 	}
 
 	// Count last container.
@@ -546,7 +550,7 @@ func (b *Bitmap) WriteTo(w io.Writer) (n int64, err error) {
 	byte8 := make([]byte, 8)
 
 	// Build header before writing individual container blocks.
-	// Metadata for each container is 8+2+2+4 = sizeof(key) + sizeof(container_type)+sizeof(cardinality) + sizeof(file offset)
+	// Metadata for each container is 8+2+2+4 = sizeof(key) + sizeof(containerType)+sizeof(cardinality) + sizeof(file offset)
 	// Cookie header section.
 
 	WriteUint32(w, byte4, cookie)
@@ -563,7 +567,7 @@ func (b *Bitmap) WriteTo(w io.Writer) (n int64, err error) {
 		//assert(c.count() == c.n, "cannot write container count, mismatch: count=%d, n=%d", count, c.n)
 		if c.n > 0 {
 			WriteUint64(w, byte8, uint64(key))
-			WriteUint16(w, byte2, uint16(c.container_type))
+			WriteUint16(w, byte2, uint16(c.containerType))
 			WriteUint16(w, byte2, uint16(c.n-1))
 		}
 	}
@@ -638,14 +642,14 @@ func (b *Bitmap) UnmarshalBinary(data []byte) error {
 		if i >= len(b.keys) {
 			b.keys = append(b.keys, binary.LittleEndian.Uint64(buf[0:8]))
 			b.containers = append(b.containers, &container{
-				container_type: byte(binary.LittleEndian.Uint16(buf[8:10])),
-				n:              int(binary.LittleEndian.Uint16(buf[10:12])) + 1,
-				mapped:         true,
+				containerType: byte(binary.LittleEndian.Uint16(buf[8:10])),
+				n:             int(binary.LittleEndian.Uint16(buf[10:12])) + 1,
+				mapped:        true,
 			})
 		} else {
 			b.keys[i] = binary.LittleEndian.Uint64(buf[0:8])
 			c := b.containers[i]
-			c.container_type = byte(binary.LittleEndian.Uint16(buf[8:10]))
+			c.containerType = byte(binary.LittleEndian.Uint16(buf[8:10]))
 			c.n = int(binary.LittleEndian.Uint16(buf[10:12])) + 1
 			c.mapped = true
 
@@ -663,7 +667,7 @@ func (b *Bitmap) UnmarshalBinary(data []byte) error {
 
 		// Map byte slice directly to the container data.
 		c := b.containers[i]
-		switch c.container_type {
+		switch c.containerType {
 		case ContainerRun:
 			c.array = nil
 			c.bitmap = nil
@@ -982,12 +986,12 @@ const RunMaxSize = 2048
 // an array or RLE container is used, depending on the contents. For containers
 // with more than 4,096 values, the values are encoded into bitmaps.
 type container struct {
-	container_type byte         // array, bitmap, or run
-	n              int          // number of integers in container
-	array          []uint16     // used for array containers
-	bitmap         []uint64     // used for bitmap containers
-	runs           []interval16 // used for RLE containers
-	mapped         bool         // mapped directly to a byte slice when true
+	containerType byte         // array, bitmap, or run
+	n             int          // number of integers in container
+	array         []uint16     // used for array containers
+	bitmap        []uint64     // used for bitmap containers
+	runs          []interval16 // used for RLE containers
+	mapped        bool         // mapped directly to a byte slice when true
 }
 
 type interval16 struct {
@@ -1002,22 +1006,22 @@ func (iv interval16) runlen() int {
 
 // newContainer returns a new instance of container.
 func newContainer() *container {
-	return &container{container_type: ContainerArray}
+	return &container{containerType: ContainerArray}
 }
 
 // isArray returns true if the container is an array container.
 func (c *container) isArray() bool {
-	return c.container_type == ContainerArray
+	return c.containerType == ContainerArray
 }
 
 // isBitmap returns true if the container is a bitmap container.
 func (c *container) isBitmap() bool {
-	return c.container_type == ContainerBitmap
+	return c.containerType == ContainerBitmap
 }
 
 // isRun returns true if the container is a run-length-encoded container.
 func (c *container) isRun() bool {
-	return c.container_type == ContainerRun
+	return c.containerType == ContainerRun
 }
 
 // unmap creates copies of the containers data in the heap.
@@ -1029,7 +1033,7 @@ func (c *container) unmap() {
 		return
 	}
 
-	switch c.container_type {
+	switch c.containerType {
 	case ContainerArray:
 		tmp := make([]uint16, len(c.array))
 		copy(tmp, c.array)
@@ -1207,7 +1211,7 @@ func (c *container) runAdd(v uint16) bool {
 	c.unmap()
 	if iv.last < v {
 		if iv.last == v-1 {
-			c.runs[i].last += 1
+			c.runs[i].last++
 		} else {
 			c.runs = append(c.runs, interval16{start: v, last: v})
 		}
@@ -1219,10 +1223,10 @@ func (c *container) runAdd(v uint16) bool {
 			return true
 		}
 		// just before an interval
-		c.runs[i].start -= 1
+		c.runs[i].start--
 	} else if i > 0 && v-1 == c.runs[i-1].last {
 		// just after an interval
-		c.runs[i-1].last += 1
+		c.runs[i-1].last++
 	} else {
 		// alone
 		newIv := interval16{start: v, last: v}
@@ -1256,7 +1260,7 @@ func (c *container) arrayCountRuns() (r int) {
 	prev := -2
 	for _, v := range c.array {
 		if prev+1 != int(v) {
-			r += 1
+			r++
 		}
 		prev = int(v)
 	}
@@ -1395,9 +1399,9 @@ func (c *container) runRemove(v uint16) bool {
 	if v == c.runs[i].last && v == c.runs[i].start {
 		c.runs = append(c.runs[:i], c.runs[i+1:]...)
 	} else if v == c.runs[i].last {
-		c.runs[i].last -= 1
+		c.runs[i].last--
 	} else if v == c.runs[i].start {
-		c.runs[i].start += 1
+		c.runs[i].start++
 	} else if v > c.runs[i].start {
 		last := c.runs[i].last
 		c.runs[i].last = v - 1
@@ -1453,7 +1457,7 @@ func (c *container) runMax() uint16 {
 // bitmapToArray converts from bitmap format to array format.
 func (c *container) bitmapToArray() {
 	c.array = make([]uint16, 0, c.n)
-	c.container_type = ContainerArray
+	c.containerType = ContainerArray
 
 	// return early if empty
 	if c.n == 0 {
@@ -1476,7 +1480,7 @@ func (c *container) bitmapToArray() {
 // arrayToBitmap converts from array format to bitmap format.
 func (c *container) arrayToBitmap() {
 	c.bitmap = make([]uint64, bitmapN)
-	c.container_type = ContainerBitmap
+	c.containerType = ContainerBitmap
 
 	// return early if empty
 	if c.n == 0 {
@@ -1495,7 +1499,7 @@ func (c *container) arrayToBitmap() {
 // runToBitmap converts from RLE format to bitmap format.
 func (c *container) runToBitmap() {
 	c.bitmap = make([]uint64, bitmapN)
-	c.container_type = ContainerBitmap
+	c.containerType = ContainerBitmap
 
 	// return early if empty
 	if c.n == 0 {
@@ -1517,7 +1521,7 @@ func (c *container) runToBitmap() {
 
 // bitmapToRun converts from bitmap format to RLE format.
 func (c *container) bitmapToRun() {
-	c.container_type = ContainerRun
+	c.containerType = ContainerRun
 	// return early if empty
 	if c.n == 0 {
 		c.runs = make([]interval16, 0)
@@ -1573,7 +1577,7 @@ func (c *container) bitmapToRun() {
 
 // arrayToRun converts from array format to RLE format.
 func (c *container) arrayToRun() {
-	c.container_type = ContainerRun
+	c.containerType = ContainerRun
 	// return early if empty
 	if c.n == 0 {
 		c.runs = make([]interval16, 0)
@@ -1600,7 +1604,7 @@ func (c *container) arrayToRun() {
 
 // runToArray converts from RLE format to array format.
 func (c *container) runToArray() {
-	c.container_type = ContainerArray
+	c.containerType = ContainerArray
 	c.array = make([]uint16, 0, c.n)
 
 	// return early if empty
@@ -1621,9 +1625,9 @@ func (c *container) runToArray() {
 
 // clone returns a copy of c.
 func (c *container) clone() *container {
-	other := &container{n: c.n, container_type: c.container_type}
+	other := &container{n: c.n, containerType: c.containerType}
 
-	switch c.container_type {
+	switch c.containerType {
 	case ContainerArray:
 		other.array = make([]uint16, len(c.array))
 		copy(other.array, c.array)
@@ -1640,7 +1644,7 @@ func (c *container) clone() *container {
 // flipBitmap returns a new bitmap containter containing the inverse of all
 // bits in c.
 func (c *container) flipBitmap() *container {
-	other := &container{bitmap: make([]uint64, bitmapN), container_type: ContainerBitmap}
+	other := &container{bitmap: make([]uint64, bitmapN), containerType: ContainerBitmap}
 
 	for i, bitmap := range c.bitmap {
 		other.bitmap[i] = ^bitmap
@@ -1918,7 +1922,7 @@ func intersect(a, b *container) *container {
 }
 
 func intersectArrayArray(a, b *container) *container {
-	output := &container{container_type: ContainerArray}
+	output := &container{containerType: ContainerArray}
 	na, nb := len(a.array), len(b.array)
 	for i, j := 0, 0; i < na && j < nb; {
 		va, vb := a.array[i], b.array[j]
@@ -1939,7 +1943,7 @@ func intersectArrayArray(a, b *container) *container {
 // container. The return is always an array container (since it's guaranteed to
 // be low-cardinality)
 func intersectArrayRun(a, b *container) *container {
-	output := &container{container_type: ContainerArray}
+	output := &container{containerType: ContainerArray}
 	na, nb := len(a.array), len(b.runs)
 	for i, j := 0, 0; i < na && j < nb; {
 		va, vb := a.array[i], b.runs[j]
@@ -1958,7 +1962,7 @@ func intersectArrayRun(a, b *container) *container {
 
 // intersectRunRun computes the intersect of two run containers.
 func intersectRunRun(a, b *container) *container {
-	output := &container{container_type: ContainerRun}
+	output := &container{containerType: ContainerRun}
 	na, nb := len(a.runs), len(b.runs)
 	for i, j := 0, 0; i < na && j < nb; {
 		va, vb := a.runs[i], b.runs[j]
@@ -2000,7 +2004,7 @@ func intersectBitmapRun(a, b *container) *container {
 	var output *container
 	if b.n < ArrayMaxSize {
 		// output is array container
-		output = &container{container_type: ContainerArray}
+		output = &container{containerType: ContainerArray}
 		for _, iv := range b.runs {
 			for i := iv.start; i <= iv.last; i++ {
 				if a.bitmapContains(i) {
@@ -2018,8 +2022,8 @@ func intersectBitmapRun(a, b *container) *container {
 		// bitmap that are in the runs. alternately, we could zero out ranges in
 		// the bitmap which are between runs.
 		output = &container{
-			bitmap:         make([]uint64, bitmapN),
-			container_type: ContainerBitmap,
+			bitmap:        make([]uint64, bitmapN),
+			containerType: ContainerBitmap,
 		}
 		for j := 0; j < len(b.runs); j++ {
 			vb := b.runs[j]
@@ -2060,7 +2064,7 @@ func intersectBitmapRun(a, b *container) *container {
 }
 
 func intersectArrayBitmap(a, b *container) *container {
-	output := &container{container_type: ContainerArray}
+	output := &container{containerType: ContainerArray}
 	for _, va := range a.array {
 		bmidx := va / 64
 		bidx := va % 64
@@ -2075,7 +2079,7 @@ func intersectArrayBitmap(a, b *container) *container {
 }
 
 func intersectBitmapBitmap(a, b *container) *container {
-	output := &container{bitmap: make([]uint64, bitmapN), container_type: ContainerBitmap}
+	output := &container{bitmap: make([]uint64, bitmapN), containerType: ContainerBitmap}
 
 	for i := range a.bitmap {
 		v := a.bitmap[i] & b.bitmap[i]
@@ -2116,7 +2120,7 @@ func union(a, b *container) *container {
 }
 
 func unionArrayArray(a, b *container) *container {
-	output := &container{container_type: ContainerArray}
+	output := &container{containerType: ContainerArray}
 	na, nb := len(a.array), len(b.array)
 	for i, j := 0, 0; ; {
 		if i >= na && j >= nb {
@@ -2152,7 +2156,7 @@ func unionArrayRun(a, b *container) *container {
 	if b.n == maxContainerVal {
 		return b.clone()
 	}
-	output := &container{container_type: ContainerRun}
+	output := &container{containerType: ContainerRun}
 	na, nb := len(a.array), len(b.runs)
 	var vb interval16
 	var va uint16
@@ -2189,18 +2193,18 @@ func (c *container) runAppendInterval(v interval16) int {
 	if len(c.runs) == 0 {
 		c.runs = append(c.runs, v)
 		return int(v.last-v.start) + 1
-	} else {
-		last := c.runs[len(c.runs)-1]
-		if last.last == maxContainerVal { //protect against overflow
-			return 0
-		}
-		if last.last+1 >= v.start && v.last > last.last {
-			c.runs[len(c.runs)-1].last = v.last
-			return int(v.last - last.last)
-		} else if last.last+1 < v.start {
-			c.runs = append(c.runs, v)
-			return int(v.last-v.start) + 1
-		}
+	}
+
+	last := c.runs[len(c.runs)-1]
+	if last.last == maxContainerVal { //protect against overflow
+		return 0
+	}
+	if last.last+1 >= v.start && v.last > last.last {
+		c.runs[len(c.runs)-1].last = v.last
+		return int(v.last - last.last)
+	} else if last.last+1 < v.start {
+		c.runs = append(c.runs, v)
+		return int(v.last-v.start) + 1
 	}
 	return 0
 }
@@ -2214,8 +2218,8 @@ func unionRunRun(a, b *container) *container {
 	}
 	na, nb := len(a.runs), len(b.runs)
 	output := &container{
-		runs:           make([]interval16, 0, na+nb),
-		container_type: ContainerRun,
+		runs:          make([]interval16, 0, na+nb),
+		containerType: ContainerRun,
 	}
 	var va, vb interval16
 	for i, j := 0, 0; i < na || j < nb; {
@@ -2334,8 +2338,8 @@ func unionArrayBitmap(a, b *container) *container {
 
 func unionBitmapBitmap(a, b *container) *container {
 	output := &container{
-		bitmap:         make([]uint64, bitmapN),
-		container_type: ContainerBitmap,
+		bitmap:        make([]uint64, bitmapN),
+		containerType: ContainerBitmap,
 	}
 
 	for i := 0; i < bitmapN; i++ {
@@ -2377,7 +2381,7 @@ func difference(a, b *container) *container {
 
 // differenceArrayArray computes the difference bween two arrays.
 func differenceArrayArray(a, b *container) *container {
-	output := &container{container_type: ContainerArray}
+	output := &container{containerType: ContainerArray}
 	na, nb := len(a.array), len(b.array)
 	for i, j := 0, 0; i < na; {
 		va := a.array[i]
@@ -2408,7 +2412,7 @@ func differenceArrayRun(a, b *container) *container {
 		return a.clone()
 	}
 
-	output := &container{array: make([]uint16, 0, a.n), container_type: ContainerArray}
+	output := &container{array: make([]uint16, 0, a.n), containerType: ContainerArray}
 	// cardinality upper bound: card(A)
 
 	i := 0 // array index
@@ -2468,7 +2472,7 @@ func differenceRunArray(a, b *container) *container {
 	if a.n == 0 || b.n == 0 {
 		return a.clone()
 	}
-	output := &container{runs: make([]interval16, 0, len(a.runs)), container_type: ContainerRun}
+	output := &container{runs: make([]interval16, 0, len(a.runs)), containerType: ContainerRun}
 
 	bidx := 0
 	vb := b.array[bidx]
@@ -2524,7 +2528,7 @@ func differenceRunBitmap(a, b *container) *container {
 	if len(a.runs) > 0 && a.runs[0].start == 0 && a.runs[0].last == 65535 {
 		return b.flipBitmap()
 	}
-	output := &container{container_type: ContainerRun}
+	output := &container{containerType: ContainerRun}
 	output.n = a.n
 	if len(a.runs) == 0 {
 		return output
@@ -2577,7 +2581,7 @@ func differenceRunBitmap(a, b *container) *container {
 
 func differenceRunIterator(a *container, itr containerIterator) *container {
 
-	output := &container{runs: make([]interval16, 0, a.n), container_type: ContainerRun}
+	output := &container{runs: make([]interval16, 0, a.n), containerType: ContainerRun}
 
 	vb, eof := itr.next()
 	j := 0
@@ -2645,7 +2649,7 @@ func differenceRunRun(a, b *container) *container {
 	alen := len(a.runs)
 	blen := len(b.runs)
 
-	output := &container{runs: make([]interval16, 0, alen+blen), container_type: ContainerRun} // TODO allocate max then truncate? or something else
+	output := &container{runs: make([]interval16, 0, alen+blen), containerType: ContainerRun} // TODO allocate max then truncate? or something else
 	// cardinality upper bound: sum of number of runs
 	// each B-run could split an A-run in two, up to len(b.runs) times
 
@@ -2695,7 +2699,7 @@ func differenceRunRun(a, b *container) *container {
 }
 
 func differenceArrayBitmap(a, b *container) *container {
-	output := &container{container_type: ContainerArray}
+	output := &container{containerType: ContainerArray}
 	for _, va := range a.array {
 		bmidx := va / 64
 		bidx := va % 64
@@ -2726,7 +2730,7 @@ func differenceBitmapArray(a, b *container) *container {
 }
 
 func differenceBitmapBitmap(a, b *container) *container {
-	output := &container{bitmap: make([]uint64, bitmapN), container_type: ContainerBitmap}
+	output := &container{bitmap: make([]uint64, bitmapN), containerType: ContainerBitmap}
 
 	for i := range a.bitmap {
 		v := a.bitmap[i] & (^b.bitmap[i])
@@ -2769,7 +2773,7 @@ func xor(a, b *container) *container {
 }
 
 func xorArrayArray(a, b *container) *container {
-	output := &container{container_type: ContainerArray}
+	output := &container{containerType: ContainerArray}
 	na, nb := len(a.array), len(b.array)
 	for i, j := 0, 0; i < na || j < nb; {
 		if i < na && j >= nb {
@@ -2816,8 +2820,8 @@ func xorArrayBitmap(a, b *container) *container {
 
 func xorBitmapBitmap(a, b *container) *container {
 	output := &container{
-		bitmap:         make([]uint64, bitmapN),
-		container_type: ContainerBitmap,
+		bitmap:        make([]uint64, bitmapN),
+		containerType: ContainerBitmap,
 	}
 	for i := 0; i < bitmapN; i++ {
 		v := a.bitmap[i] ^ b.bitmap[i]
@@ -3165,20 +3169,20 @@ func assert(condition bool, format string, a ...interface{}) {
 
 // xorArrayRun computes the exclusive or of an array and a run container.
 func xorArrayRun(a, b *container) *container {
-	output := &container{container_type: ContainerRun}
+	output := &container{containerType: ContainerRun}
 	na, nb := len(a.array), len(b.runs)
 	var vb interval16
 	var va uint16
-	last_i, last_j := -1, -1
+	lastI, lastJ := -1, -1
 	for i, j := 0, 0; i < na || j < nb; {
-		if i < na && i != last_i {
+		if i < na && i != lastI {
 			va = a.array[i]
 		}
-		if j < nb && j != last_j {
+		if j < nb && j != lastJ {
 			vb = b.runs[j]
 		}
-		last_i = i
-		last_j = j
+		lastI = i
+		lastJ = j
 
 		if i < na && (j >= nb || va < vb.start) { //before
 			output.n += output.runAppendInterval(interval16{start: va, last: va})
@@ -3228,91 +3232,91 @@ func xorArrayRun(a, b *container) *container {
 }
 
 // xorCompare computes first exclusive run between two runs.
-func xorCompare(x *xorstm) (r1 interval16, has_data bool) {
-	has_data = false
-	if !x.va_valid || !x.vb_valid {
-		if x.vb_valid {
-			x.vb_valid = false
+func xorCompare(x *xorstm) (r1 interval16, hasData bool) {
+	hasData = false
+	if !x.vaValid || !x.vbValid {
+		if x.vbValid {
+			x.vbValid = false
 			r1 = x.vb
-			has_data = true
+			hasData = true
 			return
 		}
-		if x.va_valid {
-			x.va_valid = false
+		if x.vaValid {
+			x.vaValid = false
 			r1 = x.va
-			has_data = true
+			hasData = true
 			return
 		}
 		return
 	}
 
 	if x.va.last < x.vb.start { //va  before
-		x.va_valid = false
+		x.vaValid = false
 		r1 = x.va
-		has_data = true
+		hasData = true
 	} else if x.vb.last < x.va.start { //vb before
-		x.vb_valid = false
+		x.vbValid = false
 		r1 = x.vb
-		has_data = true
+		hasData = true
 	} else if x.va.start == x.vb.start && x.va.last == x.vb.last { // Equal
-		x.va_valid = false
-		x.vb_valid = false
+		x.vaValid = false
+		x.vbValid = false
 	} else if x.va.start <= x.vb.start && x.va.last >= x.vb.last { //vb inside
-		x.vb_valid = false
+		x.vbValid = false
 		if x.va.start != x.vb.start {
 			r1 = interval16{start: x.va.start, last: x.vb.start - 1}
-			has_data = true
+			hasData = true
 		}
 
 		if x.vb.last == maxContainerVal { // Check for overflow
-			x.va_valid = false
+			x.vaValid = false
 
 		} else {
 			x.va.start = x.vb.last + 1
 			if x.va.start > x.va.last {
-				x.va_valid = false
+				x.vaValid = false
 			}
 		}
 
 	} else if x.vb.start <= x.va.start && x.vb.last >= x.va.last { //va inside
-		x.va_valid = false
+		x.vaValid = false
 		if x.vb.start != x.va.start {
 			r1 = interval16{start: x.vb.start, last: x.va.start - 1}
-			has_data = true
+			hasData = true
 		}
 
 		if x.va.last == maxContainerVal { //check for overflow
-			x.vb_valid = false
+			x.vbValid = false
 		} else {
 			x.vb.start = x.va.last + 1
 			if x.vb.start > x.vb.last {
-				x.vb_valid = false
+				x.vbValid = false
 			}
 		}
 
 	} else if x.va.start < x.vb.start && x.va.last <= x.vb.last { //va first overlap
-		x.va_valid = false
+		x.vaValid = false
 		r1 = interval16{start: x.va.start, last: x.vb.start - 1}
-		has_data = true
+		hasData = true
 		if x.va.last == maxContainerVal { // check for overflow
-			x.vb_valid = false
+			x.vbValid = false
 		} else {
 			x.vb.start = x.va.last + 1
 			if x.vb.start > x.vb.last {
-				x.vb_valid = false
+				x.vbValid = false
 			}
 		}
 	} else if x.vb.start < x.va.start && x.vb.last <= x.va.last { //vb first overlap
-		x.vb_valid = false
+		x.vbValid = false
 		r1 = interval16{start: x.vb.start, last: x.va.start - 1}
-		has_data = true
+		hasData = true
 
 		if x.vb.last == maxContainerVal { // check for overflow
-			x.va_valid = false
+			x.vaValid = false
 		} else {
 			x.va.start = x.vb.last + 1
 			if x.va.start > x.va.last {
-				x.va_valid = false
+				x.vaValid = false
 			}
 		}
 	}
@@ -3321,8 +3325,8 @@ func xorCompare(x *xorstm) (r1 interval16, has_data bool) {
 
 //stm  is state machine used to "xor" iterate over runs.
 type xorstm struct {
-	va_valid, vb_valid bool
-	va, vb             interval16
+	vaValid, vbValid bool
+	va, vb           interval16
 }
 
 // xorRunRun computes the exclusive or of two run containers.
@@ -3336,30 +3340,30 @@ func xorRunRun(a, b *container) *container {
 	}
 	output := &container{}
 
-	last_i, last_j := -1, -1
+	lastI, lastJ := -1, -1
 
 	state := &xorstm{}
 
 	for i, j := 0, 0; i < na || j < nb; {
-		if i < na && last_i != i {
+		if i < na && lastI != i {
 			state.va = a.runs[i]
-			state.va_valid = true
+			state.vaValid = true
 		}
 
-		if j < nb && last_j != j {
+		if j < nb && lastJ != j {
 			state.vb = b.runs[j]
-			state.vb_valid = true
+			state.vbValid = true
 		}
-		last_i, last_j = i, j
+		lastI, lastJ = i, j
 
 		r1, ok := xorCompare(state)
 		if ok {
 			output.n += output.runAppendInterval(r1)
 		}
-		if !state.va_valid {
+		if !state.vaValid {
 			i++
 		}
-		if !state.vb_valid {
+		if !state.vbValid {
 			j++
 		}
 
diff --git a/roaring/roaring_internal_test.go b/roaring/roaring_internal_test.go
index 8ce9ba9c1..e333ca513 100644
--- a/roaring/roaring_internal_test.go
+++ b/roaring/roaring_internal_test.go
@@ -27,11 +27,11 @@ func (iv interval16) String() string {
 }
 
 func (c *container) String() string {
-	return fmt.Sprintf("<%s container  n=%d, array[%d], runs[%d], bitmap[%d]> type:%d", c.info().Type, c.n, len(c.array), len(c.runs), len(c.bitmap), c.container_type)
+	return fmt.Sprintf("<%s container  n=%d, array[%d], runs[%d], bitmap[%d]> type:%d", c.info().Type, c.n, len(c.array), len(c.runs), len(c.bitmap), c.containerType)
 }
 
 func TestRunAppendInterval(t *testing.T) {
-	a := container{container_type: ContainerRun}
+	a := container{containerType: ContainerRun}
 	tests := []struct {
 		base []interval16
 		app  interval16
@@ -80,7 +80,7 @@ func TestInterval16RunLen(t *testing.T) {
 }
 
 func TestContainerRunAdd(t *testing.T) {
-	c := container{runs: make([]interval16, 0), container_type: ContainerRun}
+	c := container{runs: make([]interval16, 0), containerType: ContainerRun}
 	tests := []struct {
 		op  uint16
 		exp []interval16
@@ -111,7 +111,7 @@ func TestContainerRunAdd(t *testing.T) {
 }
 
 func TestContainerRunAdd2(t *testing.T) {
-	c := container{runs: make([]interval16, 0), container_type: ContainerRun}
+	c := container{runs: make([]interval16, 0), containerType: ContainerRun}
 	ret := c.add(0)
 	if !ret {
 		t.Fatalf("result of adding new bit should be true: %v", c.runs)
@@ -126,7 +126,7 @@ func TestContainerRunAdd2(t *testing.T) {
 }
 
 func TestRunCountRange(t *testing.T) {
-	c := container{runs: make([]interval16, 0), container_type: ContainerRun}
+	c := container{runs: make([]interval16, 0), containerType: ContainerRun}
 	cnt := c.runCountRange(2, 9)
 	if cnt != 0 {
 		t.Fatalf("should get 0 from empty container, but got: %v", cnt)
@@ -179,7 +179,7 @@ func TestRunCountRange(t *testing.T) {
 }
 
 func TestRunContains(t *testing.T) {
-	c := container{runs: make([]interval16, 0), container_type: ContainerRun}
+	c := container{runs: make([]interval16, 0), containerType: ContainerRun}
 	if c.runContains(5) {
 		t.Fatalf("empty run container should not contain 5")
 	}
@@ -201,7 +201,7 @@ func TestRunContains(t *testing.T) {
 }
 
 func TestBitmapCountRange(t *testing.T) {
-	c := container{container_type: ContainerBitmap}
+	c := container{containerType: ContainerBitmap}
 	tests := []struct {
 		start  int
 		end    int
@@ -227,11 +227,11 @@ func TestBitmapCountRange(t *testing.T) {
 
 func TestIntersectionCountArrayBitmap3(t *testing.T) {
 	a, b := &container{}, &container{}
-	a.container_type = ContainerBitmap
+	a.containerType = ContainerBitmap
 	a.bitmap = getFullBitmap()
 	a.n = maxContainerVal + 1
 
-	b.container_type = ContainerBitmap
+	b.containerType = ContainerBitmap
 	b.bitmap = getFullBitmap()
 	b.n = maxContainerVal + 1
 	res := intersectBitmapBitmap(a, b)
@@ -288,9 +288,9 @@ func TestIntersectionCountArrayBitmap2(t *testing.T) {
 
 	for i, test := range tests {
 		a.array = test.array
-		a.container_type = ContainerArray
+		a.containerType = ContainerArray
 		b.bitmap = test.bitmap
-		b.container_type = ContainerBitmap
+		b.containerType = ContainerBitmap
 		ret := intersectionCountArrayBitmap(a, b)
 		if ret != test.exp {
 			t.Fatalf("test #%v intersectCountArrayBitmap fail received: %v exp: %v", i, ret, test.exp)
@@ -299,7 +299,7 @@ func TestIntersectionCountArrayBitmap2(t *testing.T) {
 }
 
 func TestRunRemove(t *testing.T) {
-	c := container{runs: []interval16{{start: 2, last: 10}, {start: 12, last: 13}, {start: 15, last: 16}}, container_type: ContainerRun}
+	c := container{runs: []interval16{{start: 2, last: 10}, {start: 12, last: 13}, {start: 15, last: 16}}, containerType: ContainerRun}
 	tests := []struct {
 		op     uint16
 		exp    []interval16
@@ -333,7 +333,7 @@ func TestRunRemove(t *testing.T) {
 }
 
 func TestRunMax(t *testing.T) {
-	c := container{runs: []interval16{{start: 2, last: 10}, {start: 12, last: 13}, {start: 15, last: 16}}, container_type: ContainerRun}
+	c := container{runs: []interval16{{start: 2, last: 10}, {start: 12, last: 13}, {start: 15, last: 16}}, containerType: ContainerRun}
 	max := c.max()
 	if max != 16 {
 		t.Fatalf("max for %v should be 16", c.runs)
@@ -347,8 +347,8 @@ func TestRunMax(t *testing.T) {
 }
 
 func TestIntersectionCountArrayRun(t *testing.T) {
-	a := &container{container_type: ContainerArray, array: []uint16{1, 5, 10, 11, 12}}
-	b := &container{container_type: ContainerRun, runs: []interval16{{start: 2, last: 10}, {start: 12, last: 13}, {start: 15, last: 16}}}
+	a := &container{containerType: ContainerArray, array: []uint16{1, 5, 10, 11, 12}}
+	b := &container{containerType: ContainerRun, runs: []interval16{{start: 2, last: 10}, {start: 12, last: 13}, {start: 15, last: 16}}}
 
 	ret := intersectionCountArrayRun(a, b)
 	if ret != 3 {
@@ -357,16 +357,16 @@ func TestIntersectionCountArrayRun(t *testing.T) {
 }
 
 func TestIntersectionCountBitmapRun(t *testing.T) {
-	a := &container{container_type: ContainerBitmap, bitmap: []uint64{0x8000000000000000}}
-	b := &container{container_type: ContainerRun, runs: []interval16{{start: 63, last: 64}}}
+	a := &container{containerType: ContainerBitmap, bitmap: []uint64{0x8000000000000000}}
+	b := &container{containerType: ContainerRun, runs: []interval16{{start: 63, last: 64}}}
 
 	ret := intersectionCountBitmapRun(a, b)
 	if ret != 1 {
 		t.Fatalf("count of %v with %v should be 1, but got %v", a.bitmap, b.runs, ret)
 	}
 
-	a = &container{container_type: ContainerBitmap, bitmap: []uint64{0xF0000001, 0xFF00000000000000, 0xFF000000000000F0, 0x0F0000}}
-	b = &container{container_type: ContainerRun, runs: []interval16{{start: 29, last: 31}, {start: 125, last: 134}, {start: 191, last: 197}, {start: 200, last: 300}}}
+	a = &container{containerType: ContainerBitmap, bitmap: []uint64{0xF0000001, 0xFF00000000000000, 0xFF000000000000F0, 0x0F0000}}
+	b = &container{containerType: ContainerRun, runs: []interval16{{start: 29, last: 31}, {start: 125, last: 134}, {start: 191, last: 197}, {start: 200, last: 300}}}
 
 	ret = intersectionCountBitmapRun(a, b)
 	if ret != 14 {
@@ -414,8 +414,8 @@ func TestIntersectionCountRunRun(t *testing.T) {
 			bruns: []interval16{{start: 9, last: 9}, {start: 11, last: 17}}, exp: 6},
 	}
 	for i, test := range tests {
-		a.container_type = ContainerRun
-		b.container_type = ContainerRun
+		a.containerType = ContainerRun
+		b.containerType = ContainerRun
 		a.runs = test.aruns
 		b.runs = test.bruns
 		ret := intersectionCountRunRun(a, b)
@@ -456,8 +456,8 @@ func TestIntersectArrayRun(t *testing.T) {
 	}
 
 	for i, test := range tests {
-		a.container_type = ContainerArray
-		b.container_type = ContainerRun
+		a.containerType = ContainerArray
+		b.containerType = ContainerRun
 		a.array = test.array
 		b.runs = test.runs
 		ret := intersectArrayRun(a, b)
@@ -514,8 +514,8 @@ func TestIntersectRunRun(t *testing.T) {
 		},
 	}
 	for i, test := range tests {
-		a.container_type = ContainerRun
-		b.container_type = ContainerRun
+		a.containerType = ContainerRun
+		b.containerType = ContainerRun
 		a.runs = test.aruns
 		b.runs = test.bruns
 		ret := intersectRunRun(a, b)
@@ -579,8 +579,8 @@ func TestIntersectBitmapRunBitmap(t *testing.T) {
 		for i, v := range test.exp {
 			exp[i] = v
 		}
-		a.container_type = ContainerBitmap
-		b.container_type = ContainerRun
+		a.containerType = ContainerBitmap
+		b.containerType = ContainerRun
 		ret := intersectBitmapRun(a, b)
 		if ret.isArray() {
 			ret.arrayToBitmap()
@@ -640,8 +640,8 @@ func TestIntersectBitmapRunArray(t *testing.T) {
 			a.bitmap[i] = v
 		}
 		b.runs = test.runs
-		a.container_type = ContainerBitmap
-		b.container_type = ContainerRun
+		a.containerType = ContainerBitmap
+		b.containerType = ContainerRun
 		ret := intersectBitmapRun(a, b)
 		if !reflect.DeepEqual(ret.array, test.exp) {
 			t.Fatalf("test #%v expected %v, but got %v", i, test.exp, ret.array)
@@ -658,19 +658,19 @@ func TestUnionMixed(t *testing.T) {
 	// array container
 	a := &container{}
 	a.array = []uint16{1, 4, 5, 7, 10, 11, 12}
-	a.container_type = ContainerArray
+	a.containerType = ContainerArray
 	a.n = 7
 
 	// bitmap container
 	b := &container{bitmap: make([]uint64, bitmapN)}
 	b.bitmap[0] = uint64(0x3)
 	b.n = 2
-	b.container_type = ContainerBitmap
+	b.containerType = ContainerBitmap
 
 	// run container
 	r := &container{}
 	r.runs = []interval16{{start: 5, last: 10}}
-	r.container_type = ContainerRun
+	r.containerType = ContainerRun
 	r.n = 6
 
 	t.Run("various container Unions", func(t *testing.T) {
@@ -711,10 +711,10 @@ func TestIntersectMixed(t *testing.T) {
 
 	a.runs = []interval16{{start: 5, last: 10}}
 	a.n = 6
-	a.container_type = ContainerRun
+	a.containerType = ContainerRun
 	b.array = []uint16{1, 4, 5, 7, 10, 11, 12}
 	b.n = 7
-	b.container_type = ContainerArray
+	b.containerType = ContainerArray
 	res := intersect(a, b)
 	if !reflect.DeepEqual(res.array, []uint16{5, 7, 10}) {
 		t.Fatalf("test #1 expected %v, but got %v", []uint16{5, 7, 10}, res.array)
@@ -730,7 +730,7 @@ func TestIntersectMixed(t *testing.T) {
 	}
 	c.bitmap = []uint64{0x60}
 	c.n = 2
-	c.container_type = ContainerBitmap
+	c.containerType = ContainerBitmap
 
 	res = intersect(c, a)
 	if !reflect.DeepEqual(res.array, []uint16{5, 6}) {
@@ -760,15 +760,15 @@ func TestDifferenceMixed(t *testing.T) {
 
 	a.runs = []interval16{{start: 5, last: 10}}
 	a.n = a.runCountRange(0, 100)
-	a.container_type = ContainerRun
+	a.containerType = ContainerRun
 
 	b.array = []uint16{0, 2, 4, 6, 8, 10, 12}
 	b.n = len(b.array)
-	b.container_type = ContainerArray
+	b.containerType = ContainerArray
 
 	d.array = []uint16{1, 3, 5, 7, 9, 11, 12}
 	d.n = len(d.array)
-	d.container_type = ContainerArray
+	d.containerType = ContainerArray
 
 	res := difference(a, b)
 
@@ -788,7 +788,7 @@ func TestDifferenceMixed(t *testing.T) {
 
 	c.bitmap = []uint64{0x64}
 	c.n = c.countRange(0, 100)
-	c.container_type = ContainerBitmap
+	c.containerType = ContainerBitmap
 	res = difference(c, a)
 	if !reflect.DeepEqual(res.bitmap, []uint64{0x4}) {
 		t.Fatalf("test #4 expected %v, but got %v", []uint16{4}, res.bitmap)
@@ -883,8 +883,8 @@ func TestUnionRunRun(t *testing.T) {
 	for i, test := range tests {
 		a.runs = test.aruns
 		b.runs = test.bruns
-		a.container_type = ContainerRun
-		b.container_type = ContainerRun
+		a.containerType = ContainerRun
+		b.containerType = ContainerRun
 		ret := unionRunRun(a, b)
 		if !reflect.DeepEqual(ret.runs, test.exp) {
 			t.Fatalf("test #%v expected %v, but got %v", i, test.exp, ret.runs)
@@ -925,8 +925,8 @@ func TestUnionArrayRun(t *testing.T) {
 	for i, test := range tests {
 		a.array = test.array
 		b.runs = test.runs
-		a.container_type = ContainerArray
-		b.container_type = ContainerRun
+		a.containerType = ContainerArray
+		b.containerType = ContainerRun
 		ret := unionArrayRun(a, b)
 		if !reflect.DeepEqual(ret.array, test.exp) {
 			t.Fatalf("test #%v expected %v, but got %v", i, test.exp, ret.array)
@@ -935,7 +935,7 @@ func TestUnionArrayRun(t *testing.T) {
 }
 
 func TestBitmapSetRange(t *testing.T) {
-	c := &container{container_type: ContainerBitmap, bitmap: make([]uint64, bitmapN)}
+	c := &container{containerType: ContainerBitmap, bitmap: make([]uint64, bitmapN)}
 	tests := []struct {
 		bitmap []uint64
 		start  uint64
@@ -975,7 +975,7 @@ func TestBitmapSetRange(t *testing.T) {
 }
 
 func TestArrayToBitmap(t *testing.T) {
-	a := &container{container_type: ContainerArray}
+	a := &container{containerType: ContainerArray}
 	tests := []struct {
 		array []uint16
 		exp   []uint64
@@ -1006,7 +1006,7 @@ func TestArrayToBitmap(t *testing.T) {
 }
 
 func TestBitmapToArray(t *testing.T) {
-	a := &container{container_type: ContainerBitmap}
+	a := &container{containerType: ContainerBitmap}
 	tests := []struct {
 		bitmap []uint64
 		exp    []uint16
@@ -1037,7 +1037,7 @@ func TestBitmapToArray(t *testing.T) {
 }
 
 func TestRunToBitmap(t *testing.T) {
-	a := &container{container_type: ContainerRun}
+	a := &container{containerType: ContainerRun}
 	tests := []struct {
 		runs []interval16
 		exp  []uint64
@@ -1091,7 +1091,7 @@ func getFullBitmap() []uint64 {
 }
 
 func TestBitmapToRun(t *testing.T) {
-	a := &container{container_type: ContainerBitmap}
+	a := &container{containerType: ContainerBitmap}
 	tests := []struct {
 		bitmap []uint64
 		exp    []interval16
@@ -1169,7 +1169,7 @@ func TestBitmapToRun(t *testing.T) {
 }
 
 func TestArrayToRun(t *testing.T) {
-	a := &container{container_type: ContainerArray}
+	a := &container{containerType: ContainerArray}
 	tests := []struct {
 		array []uint16
 		exp   []interval16
@@ -1203,7 +1203,7 @@ func TestArrayToRun(t *testing.T) {
 }
 
 func TestRunToArray(t *testing.T) {
-	a := &container{container_type: ContainerRun}
+	a := &container{containerType: ContainerRun}
 	tests := []struct {
 		runs []interval16
 		exp  []uint16
@@ -1237,7 +1237,7 @@ func TestRunToArray(t *testing.T) {
 }
 
 func TestBitmapZeroRange(t *testing.T) {
-	c := &container{container_type: ContainerBitmap, bitmap: make([]uint64, bitmapN)}
+	c := &container{containerType: ContainerBitmap, bitmap: make([]uint64, bitmapN)}
 	tests := []struct {
 		bitmap []uint64
 		start  uint64
@@ -1273,7 +1273,7 @@ func TestBitmapZeroRange(t *testing.T) {
 		if test.expN != c.n {
 			t.Fatalf("test #%v expected n to be %v, but got %v", i, test.expN, c.n)
 		}
-		for i, _ := range test.bitmap {
+		for i := range test.bitmap {
 			c.bitmap[i] = 0
 		}
 	}
@@ -1281,8 +1281,8 @@ func TestBitmapZeroRange(t *testing.T) {
 }
 
 func TestUnionBitmapRun(t *testing.T) {
-	a := &container{container_type: ContainerBitmap, bitmap: make([]uint64, bitmapN)}
-	b := &container{container_type: ContainerRun}
+	a := &container{containerType: ContainerBitmap, bitmap: make([]uint64, bitmapN)}
+	b := &container{containerType: ContainerRun}
 	tests := []struct {
 		bitmap []uint64
 		runs   []interval16
@@ -1313,14 +1313,14 @@ func TestUnionBitmapRun(t *testing.T) {
 		if ret.n != test.expN {
 			t.Fatalf("test #%v expected n to be %v, but got %v", i, test.expN, ret.n)
 		}
-		for i, _ := range test.bitmap {
+		for i := range test.bitmap {
 			a.bitmap[i] = 0
 		}
 	}
 }
 
 func TestBitmapCountRuns(t *testing.T) {
-	c := &container{container_type: ContainerBitmap, bitmap: make([]uint64, bitmapN)}
+	c := &container{containerType: ContainerBitmap, bitmap: make([]uint64, bitmapN)}
 	tests := []struct {
 		bitmap []uint64
 		exp    int
@@ -1353,7 +1353,7 @@ func TestBitmapCountRuns(t *testing.T) {
 			t.Fatalf("test #%v expected %v but got %v", i, test.exp, ret)
 		}
 
-		for j, _ := range test.bitmap {
+		for j := range test.bitmap {
 			c.bitmap[j] = 0
 		}
 	}
@@ -1370,7 +1370,7 @@ func TestBitmapCountRuns(t *testing.T) {
 }
 
 func TestArrayCountRuns(t *testing.T) {
-	c := &container{container_type: ContainerArray}
+	c := &container{containerType: ContainerArray}
 	tests := []struct {
 		array []uint16
 		exp   int
@@ -1411,8 +1411,8 @@ func TestArrayCountRuns(t *testing.T) {
 }
 
 func TestDifferenceArrayRun(t *testing.T) {
-	a := &container{container_type: ContainerArray}
-	b := &container{container_type: ContainerRun}
+	a := &container{containerType: ContainerArray}
+	b := &container{containerType: ContainerRun}
 	tests := []struct {
 		array []uint16
 		runs  []interval16
@@ -1437,8 +1437,8 @@ func TestDifferenceArrayRun(t *testing.T) {
 }
 
 func TestDifferenceRunArray(t *testing.T) {
-	a := &container{container_type: ContainerRun}
-	b := &container{container_type: ContainerArray}
+	a := &container{containerType: ContainerRun}
+	b := &container{containerType: ContainerArray}
 	tests := []struct {
 		runs  []interval16
 		array []uint16
@@ -1518,8 +1518,8 @@ func MakeLastBitSet() []uint64 {
 }
 
 func TestDifferenceRunBitmap(t *testing.T) {
-	a := &container{container_type: ContainerRun}
-	b := &container{container_type: ContainerBitmap, bitmap: make([]uint64, bitmapN)}
+	a := &container{containerType: ContainerRun}
+	b := &container{containerType: ContainerBitmap, bitmap: make([]uint64, bitmapN)}
 	tests := []struct {
 		runs   []interval16
 		bitmap []uint64
@@ -1581,8 +1581,8 @@ func TestDifferenceRunBitmap(t *testing.T) {
 }
 
 func TestDifferenceBitmapRun(t *testing.T) {
-	a := &container{container_type: ContainerBitmap, bitmap: make([]uint64, bitmapN)}
-	b := &container{container_type: ContainerRun}
+	a := &container{containerType: ContainerBitmap, bitmap: make([]uint64, bitmapN)}
+	b := &container{containerType: ContainerRun}
 	tests := []struct {
 		bitmap []uint64
 		runs   []interval16
@@ -1664,8 +1664,8 @@ func TestDifferenceBitmapRun(t *testing.T) {
 }
 
 func TestDifferenceBitmapArray(t *testing.T) {
-	b := &container{container_type: ContainerBitmap, bitmap: make([]uint64, bitmapN)}
-	a := &container{container_type: ContainerArray}
+	b := &container{containerType: ContainerBitmap, bitmap: make([]uint64, bitmapN)}
+	a := &container{containerType: ContainerArray}
 	tests := []struct {
 		bitmap []uint64
 		array  []uint16
@@ -1714,8 +1714,8 @@ func TestDifferenceBitmapArray(t *testing.T) {
 }
 
 func TestDifferenceBitmapBitmap(t *testing.T) {
-	a := &container{bitmap: make([]uint64, bitmapN), container_type: ContainerBitmap}
-	b := &container{bitmap: make([]uint64, bitmapN), container_type: ContainerBitmap}
+	a := &container{bitmap: make([]uint64, bitmapN), containerType: ContainerBitmap}
+	b := &container{bitmap: make([]uint64, bitmapN), containerType: ContainerBitmap}
 	tests := []struct {
 		abitmap []uint64
 		bbitmap []uint64
@@ -1744,8 +1744,8 @@ func TestDifferenceBitmapBitmap(t *testing.T) {
 }
 
 func TestDifferenceRunRun(t *testing.T) {
-	a := &container{container_type: ContainerRun}
-	b := &container{container_type: ContainerRun}
+	a := &container{containerType: ContainerRun}
+	b := &container{containerType: ContainerRun}
 	tests := []struct {
 		aruns []interval16
 		bruns []interval16
@@ -1778,7 +1778,7 @@ func TestDifferenceRunRun(t *testing.T) {
 }
 
 func TestWriteReadArray(t *testing.T) {
-	ca := &container{array: []uint16{1, 10, 100, 1000}, n: 4, container_type: ContainerArray}
+	ca := &container{array: []uint16{1, 10, 100, 1000}, n: 4, containerType: ContainerArray}
 	ba := &Bitmap{keys: []uint64{0}, containers: []*container{ca}}
 	ba2 := &Bitmap{}
 	var buf bytes.Buffer
@@ -1797,7 +1797,7 @@ func TestWriteReadArray(t *testing.T) {
 
 func TestWriteReadBitmap(t *testing.T) {
 	// create bitmap containing > 4096 bits
-	cb := &container{bitmap: make([]uint64, bitmapN), n: 129 * 32, container_type: ContainerBitmap}
+	cb := &container{bitmap: make([]uint64, bitmapN), n: 129 * 32, containerType: ContainerBitmap}
 	for i := 0; i < 129; i++ {
 		cb.bitmap[i] = 0x5555555555555555
 	}
@@ -1819,7 +1819,7 @@ func TestWriteReadBitmap(t *testing.T) {
 
 func TestWriteReadFullBitmap(t *testing.T) {
 	// create bitmap containing > 4096 bits
-	cb := &container{bitmap: make([]uint64, bitmapN), n: 65536, container_type: ContainerBitmap}
+	cb := &container{bitmap: make([]uint64, bitmapN), n: 65536, containerType: ContainerBitmap}
 	for i := 0; i < bitmapN; i++ {
 		cb.bitmap[i] = 0xffffffffffffffff
 	}
@@ -1847,7 +1847,7 @@ func TestWriteReadFullBitmap(t *testing.T) {
 }
 
 func TestWriteReadRun(t *testing.T) {
-	cr := &container{runs: []interval16{{start: 3, last: 13}, {start: 100, last: 109}}, n: 21, container_type: ContainerRun}
+	cr := &container{runs: []interval16{{start: 3, last: 13}, {start: 100, last: 109}}, n: 21, containerType: ContainerRun}
 	br := &Bitmap{keys: []uint64{0}, containers: []*container{cr}}
 	br2 := &Bitmap{}
 	var buf bytes.Buffer
@@ -1871,21 +1871,21 @@ func TestXorArrayRun(t *testing.T) {
 		exp *container
 	}{
 		{
-			a:   &container{array: []uint16{1, 5, 10, 11, 12}, container_type: ContainerArray},
-			b:   &container{runs: []interval16{{start: 2, last: 10}, {start: 12, last: 13}, {start: 15, last: 16}}, container_type: ContainerRun},
-			exp: &container{array: []uint16{1, 2, 3, 4, 6, 7, 8, 9, 11, 13, 15, 16}, container_type: ContainerArray, n: 12},
+			a:   &container{array: []uint16{1, 5, 10, 11, 12}, containerType: ContainerArray},
+			b:   &container{runs: []interval16{{start: 2, last: 10}, {start: 12, last: 13}, {start: 15, last: 16}}, containerType: ContainerRun},
+			exp: &container{array: []uint16{1, 2, 3, 4, 6, 7, 8, 9, 11, 13, 15, 16}, containerType: ContainerArray, n: 12},
 		}, {
-			a:   &container{array: []uint16{1, 5, 10, 11, 12, 13, 14}, container_type: ContainerArray},
-			b:   &container{runs: []interval16{{start: 2, last: 10}, {start: 12, last: 13}, {start: 15, last: 16}}, container_type: ContainerRun},
-			exp: &container{array: []uint16{1, 2, 3, 4, 6, 7, 8, 9, 11, 14, 15, 16}, container_type: ContainerArray, n: 12},
+			a:   &container{array: []uint16{1, 5, 10, 11, 12, 13, 14}, containerType: ContainerArray},
+			b:   &container{runs: []interval16{{start: 2, last: 10}, {start: 12, last: 13}, {start: 15, last: 16}}, containerType: ContainerRun},
+			exp: &container{array: []uint16{1, 2, 3, 4, 6, 7, 8, 9, 11, 14, 15, 16}, containerType: ContainerArray, n: 12},
 		}, {
-			a:   &container{array: []uint16{65535}, container_type: ContainerArray},
-			b:   &container{runs: []interval16{{start: 65534, last: 65535}}, container_type: ContainerRun},
-			exp: &container{array: []uint16{65534}, container_type: ContainerArray, n: 1},
+			a:   &container{array: []uint16{65535}, containerType: ContainerArray},
+			b:   &container{runs: []interval16{{start: 65534, last: 65535}}, containerType: ContainerRun},
+			exp: &container{array: []uint16{65534}, containerType: ContainerArray, n: 1},
 		}, {
-			a:   &container{array: []uint16{65535}, container_type: ContainerArray},
-			b:   &container{runs: []interval16{{start: 65535, last: 65535}}, container_type: ContainerRun},
-			exp: &container{array: []uint16{}, container_type: ContainerArray, n: 0},
+			a:   &container{array: []uint16{65535}, containerType: ContainerArray},
+			b:   &container{runs: []interval16{{start: 65535, last: 65535}}, containerType: ContainerRun},
+			exp: &container{array: []uint16{}, containerType: ContainerArray, n: 0},
 		},
 	}
 
@@ -1906,8 +1906,8 @@ func TestXorArrayRun(t *testing.T) {
 
 //special case that didn't fit the xorrunrun table testing below.
 func TestXorRunRun1(t *testing.T) {
-	a := &container{container_type: ContainerRun}
-	b := &container{container_type: ContainerRun}
+	a := &container{containerType: ContainerRun}
+	b := &container{containerType: ContainerRun}
 	a.runs = []interval16{{start: 4, last: 10}}
 	b.runs = []interval16{{start: 5, last: 10}}
 	ret := xorRunRun(a, b)
@@ -1921,8 +1921,8 @@ func TestXorRunRun1(t *testing.T) {
 }
 
 func TestXorRunRun(t *testing.T) {
-	a := &container{container_type: ContainerRun}
-	b := &container{container_type: ContainerRun}
+	a := &container{containerType: ContainerRun}
+	b := &container{containerType: ContainerRun}
 	tests := []struct {
 		aruns []interval16
 		bruns []interval16
@@ -2019,7 +2019,7 @@ func TestXorRunRun(t *testing.T) {
 }
 
 func TestBitmapFlip(t *testing.T) {
-	c := &container{bitmap: make([]uint64, bitmapN), container_type: ContainerBitmap}
+	c := &container{bitmap: make([]uint64, bitmapN), containerType: ContainerBitmap}
 
 	ttable := []struct {
 		original uint64
@@ -2051,7 +2051,7 @@ func TestBitmapFlip(t *testing.T) {
 }
 
 func TestBitmapXorRange(t *testing.T) {
-	c := &container{bitmap: make([]uint64, bitmapN), container_type: ContainerBitmap}
+	c := &container{bitmap: make([]uint64, bitmapN), containerType: ContainerBitmap}
 	tests := []struct {
 		bitmap []uint64
 		start  uint64
@@ -2119,8 +2119,8 @@ func TestBitmapXorRange(t *testing.T) {
 }
 
 func TestXorBitmapRun(t *testing.T) {
-	a := &container{container_type: ContainerBitmap}
-	b := &container{container_type: ContainerRun}
+	a := &container{containerType: ContainerBitmap}
+	b := &container{containerType: ContainerRun}
 	tests := []struct {
 		bitmap []uint64
 		runs   []interval16
@@ -2631,9 +2631,9 @@ func TestSearch64(t *testing.T) {
 }
 
 func TestIntersectArrayBitmap(t *testing.T) {
-	a, b := &container{container_type: ContainerArray}, &container{
-		container_type: ContainerBitmap,
-		bitmap:         make([]uint64, bitmapN),
+	a, b := &container{containerType: ContainerArray}, &container{
+		containerType: ContainerBitmap,
+		bitmap:        make([]uint64, bitmapN),
 	}
 	tests := []struct {
 		array  []uint16
@@ -2679,11 +2679,11 @@ func TestIntersectArrayBitmap(t *testing.T) {
 
 	for i, test := range tests {
 		a.array = test.array
-		a.container_type = ContainerArray
+		a.containerType = ContainerArray
 		for i, bmval := range test.bitmap {
 			b.bitmap[i] = bmval
 		}
-		b.container_type = ContainerBitmap
+		b.containerType = ContainerBitmap
 		ret := intersectArrayBitmap(a, b).array
 		if len(ret) == 0 && len(test.exp) == 0 {
 			continue