codec: test: add tests for symbols, and nil or 0-length fast-path slices and maps

Added some fixes along the way

improve definitelyNil

    document that it is best-effort.
    Also use a bitset32 to track it (and eliminate too many conditionals)

always EncodeNil in fast-path

    There is no global way of checking if an interface is nil.
    For true references (map, ptr, func, chan), you can just look
    at the word of the interface. However, for slices, you have to dereference
    the word, and get a pointer to the 3-word interface value.

    Consequently, we cannot depend on the definintelyNil function,
    which is just a best effort thing.

decode.go: setzero doesn't error if not decodeable

codec/decode.go

@@ -2016,6 +2016,7 @@ func (d *Decoder) setZero(iv interface{}) {
 	if iv == nil || definitelyNil(iv) {
 		return
 	}
+	var canDecode bool
 	switch v := iv.(type) {
 	case *string:
 		*v = ""
@@ -2050,15 +2051,13 @@ func (d *Decoder) setZero(iv interface{}) {
 	case *Raw:
 		*v = nil
 	case reflect.Value:
-		v = d.ensureDecodeable(v)
-		if v.CanSet() {
+		if v, canDecode = isDecodeable(v); canDecode && v.CanSet() {
 			v.Set(reflect.Zero(v.Type()))
 		} // TODO: else drain if chan, clear if map, set all to nil if slice???
 	default:
 		if !fastpathDecodeSetZeroTypeSwitch(iv, d) {
 			v := reflect.ValueOf(iv)
-			v = d.ensureDecodeable(v)
-			if v.CanSet() {
+			if v, canDecode = isDecodeable(v); canDecode && v.CanSet() {
 				v.Set(reflect.Zero(v.Type()))
 			} // TODO: else drain if chan, clear if map, set all to nil if slice???
 		}

codec/fast-path.go.tmpl

@@ -167,6 +167,7 @@ func (e *Encoder) {{ .MethodNamePfx "fastpathEnc" false }}R(f *codecFnInfo, rv r
 	}
 }
 func (_ fastpathT) {{ .MethodNamePfx "Enc" false }}V(v []{{ .Elem }}, e *Encoder) {
+	if v == nil { e.e.EncodeNil(); return }
 	ee, esep := e.e, e.hh.hasElemSeparators()
 	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
@@ -204,6 +205,7 @@ func (e *Encoder) {{ .MethodNamePfx "fastpathEnc" false }}R(f *codecFnInfo, rv r
 	fastpathTV.{{ .MethodNamePfx "Enc" false }}V(rv2i(rv).(map[{{ .MapKey }}]{{ .Elem }}), e)
 }
 func (_ fastpathT) {{ .MethodNamePfx "Enc" false }}V(v map[{{ .MapKey }}]{{ .Elem }}, e *Encoder) {
+	if v == nil { e.e.EncodeNil(); return }
 	ee, esep := e.e, e.hh.hasElemSeparators() 
 	ee.WriteMapStart(len(v))
 	{{if eq .MapKey "string"}}asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
@@ -316,7 +318,6 @@ func (d *Decoder) {{ .MethodNamePfx "fastpathDec" false }}R(f *codecFnInfo, rv r
 		fastpathTV.{{ .MethodNamePfx "Dec" false }}V(rv2i(rv).([]{{ .Elem }}), !array, d)
 	}
 }
-
 func (f fastpathT) {{ .MethodNamePfx "Dec" false }}X(vp *[]{{ .Elem }}, d *Decoder) {
 	if v, changed := f.{{ .MethodNamePfx "Dec" false }}V(*vp, true, d); changed {
 		*vp = v 

codec/helper.go

@@ -171,10 +171,17 @@ var (
 	zeroByteSlice = oneByteArr[:0:0]
 )
 
+var refBitset bitset32
+
 var pool pooler
 
 func init() {
 	pool.init()
+
+	refBitset.set(byte(reflect.Map))
+	refBitset.set(byte(reflect.Ptr))
+	refBitset.set(byte(reflect.Func))
+	refBitset.set(byte(reflect.Chan))
 }
 
 // type findCodecFnMode uint8
@@ -1901,6 +1908,18 @@ func (x *bitset128) isset(pos byte) bool {
 	return x[pos>>3]&(1<<(pos&7)) != 0
 }
 
+type bitset32 [4]byte
+
+func (x *bitset32) set(pos byte) {
+	x[pos>>3] |= (1 << (pos & 7))
+}
+func (x *bitset32) unset(pos byte) {
+	x[pos>>3] &^= (1 << (pos & 7))
+}
+func (x *bitset32) isset(pos byte) bool {
+	return x[pos>>3]&(1<<(pos&7)) != 0
+}
+
 // ------------
 
 type pooler struct {

codec/helper_not_unsafe.go

@@ -33,6 +33,8 @@ func bytesView(v string) []byte {
 }
 
 func definitelyNil(v interface{}) bool {
+	// this is a best-effort option.
+	// We just return false, so we don't unneessarily incur the cost of reflection this early.
 	return false
 	// rv := reflect.ValueOf(v)
 	// switch rv.Kind() {

codec/helper_unsafe.go

@@ -64,7 +64,16 @@ func bytesView(v string) []byte {
 }
 
 func definitelyNil(v interface{}) bool {
-	return (*unsafeIntf)(unsafe.Pointer(&v)).word == nil
+	// There is no global way of checking if an interface is nil.
+	// For true references (map, ptr, func, chan), you can just look
+	// at the word of the interface. However, for slices, you have to dereference
+	// the word, and get a pointer to the 3-word interface value.
+
+	// var ui *unsafeIntf = (*unsafeIntf)(unsafe.Pointer(&v))
+	// var word unsafe.Pointer = ui.word
+	// // fmt.Printf(">>>> definitely nil: isnil: %v, TYPE: \t%T, word: %v, *word: %v, type: %v, nil: %v\n", v == nil, v, word, *((*unsafe.Pointer)(word)), ui.typ, nil)
+	// return word == nil // || *((*unsafe.Pointer)(word)) == nil
+	return ((*unsafeIntf)(unsafe.Pointer(&v))).word == nil
 }
 
 // func keepAlive4BytesView(v string) {
@@ -81,16 +90,19 @@ func definitelyNil(v interface{}) bool {
 // the source go stdlib reflect/value.go,
 // and trims the implementation.
 func rv2i(rv reflect.Value) interface{} {
-	if false {
-		return rv.Interface()
-	}
 	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
-	// references that are single-words (map, ptr) may be double-referenced as flagIndir
-	kk := urv.flag & (1<<5 - 1)
-	if (kk == uintptr(reflect.Map) || kk == uintptr(reflect.Ptr)) && urv.flag&unsafeFlagIndir != 0 {
-		return *(*interface{})(unsafe.Pointer(&unsafeIntf{word: *(*unsafe.Pointer)(urv.ptr), typ: urv.typ}))
+	// true references (map, func, chan, ptr - NOT slice) may be double-referenced as flagIndir
+	var ptr unsafe.Pointer
+	// kk := reflect.Kind(urv.flag & (1<<5 - 1))
+	// if (kk == reflect.Map || kk == reflect.Ptr || kk == reflect.Chan || kk == reflect.Func) && urv.flag&unsafeFlagIndir != 0 {
+	if refBitset.isset(byte(urv.flag&(1<<5-1))) && urv.flag&unsafeFlagIndir != 0 {
+		ptr = *(*unsafe.Pointer)(urv.ptr)
+	} else {
+		ptr = urv.ptr
 	}
-	return *(*interface{})(unsafe.Pointer(&unsafeIntf{word: urv.ptr, typ: urv.typ}))
+	return *(*interface{})(unsafe.Pointer(&unsafeIntf{typ: urv.typ, word: ptr}))
+	// return *(*interface{})(unsafe.Pointer(&unsafeIntf{word: *(*unsafe.Pointer)(urv.ptr), typ: urv.typ}))
+	// return *(*interface{})(unsafe.Pointer(&unsafeIntf{word: urv.ptr, typ: urv.typ}))
 }
 
 func rt2id(rt reflect.Type) uintptr {

codec/mammoth-test.go.tmpl

@@ -9,12 +9,15 @@
 package codec
 
 import "testing"
+import "fmt"
 
 // TestMammoth has all the different paths optimized in fast-path
 // It has all the primitives, slices and maps.
 // 
 // For each of those types, it has a pointer and a non-pointer field.
 
+func init() { _ = fmt.Printf } // so we can include fmt as needed
+
 type TestMammoth struct {
 
 {{range .Values }}{{if .Primitive }}{{/*
@@ -42,42 +45,51 @@ func (_ {{ .MethodNamePfx "type" false }}) MapBySlice() { }
 func doTestMammothSlices(t *testing.T, h Handle) {
 {{range $i, $e := .Values }}{{if not .Primitive }}{{if not .MapKey }}{{/*
 */}}
-	v{{$i}}v1 := []{{ .Elem }}{ {{ nonzerocmd .Elem }}, {{ nonzerocmd .Elem }} }
-	bs{{$i}}, _ := testMarshalErr(v{{$i}}v1, h, t, "-")
-	v{{$i}}v2 := make([]{{ .Elem }}, 2)
-	testUnmarshalErr(v{{$i}}v2, bs{{$i}}, h, t, "-")
-	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "-")
-	bs{{$i}}, _ = testMarshalErr(&v{{$i}}v1, h, t, "-")
+    for _, v := range [][]{{ .Elem }}{ nil, []{{ .Elem }}{}, []{{ .Elem }}{ {{ nonzerocmd .Elem }}, {{ nonzerocmd .Elem }} } } {
+    // fmt.Printf(">>>> running mammoth slice v{{$i}}: %v\n", v)
+    var v{{$i}}v1, v{{$i}}v2, v{{$i}}v3, v{{$i}}v4 []{{ .Elem }}
+	v{{$i}}v1 = v
+	bs{{$i}}, _ := testMarshalErr(v{{$i}}v1, h, t, "enc-slice-v{{$i}}")
+    if v != nil { v{{$i}}v2 = make([]{{ .Elem }}, len(v)) }
+	testUnmarshalErr(v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}")
+	bs{{$i}}, _ = testMarshalErr(&v{{$i}}v1, h, t, "enc-slice-v{{$i}}-p")
 	v{{$i}}v2 = nil
-	testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "-")
-	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "-")
+	testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}-p")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-p")
     // ...
-    v{{$i}}v2 = make([]{{ .Elem }}, 2)
-    v{{$i}}v3 := {{ .MethodNamePfx "type" false }}(v{{$i}}v1)
-    bs{{$i}}, _ = testMarshalErr(v{{$i}}v3, h, t, "-")
-    v{{$i}}v4 := {{ .MethodNamePfx "type" false }}(v{{$i}}v2)
-    testUnmarshalErr(v{{$i}}v4, bs{{$i}}, h, t, "-")
-    testDeepEqualErr(v{{$i}}v3, v{{$i}}v4, t, "-")
+	v{{$i}}v2 = nil
+    if v != nil { v{{$i}}v2 = make([]{{ .Elem }}, len(v)) }
+    v{{$i}}v3 = {{ .MethodNamePfx "type" false }}(v{{$i}}v1)
+    bs{{$i}}, _ = testMarshalErr(v{{$i}}v3, h, t, "enc-slice-v{{$i}}-custom")
+    v{{$i}}v4 = {{ .MethodNamePfx "type" false }}(v{{$i}}v2)
+    testUnmarshalErr(v{{$i}}v4, bs{{$i}}, h, t, "dec-slice-v{{$i}}-custom")
+    testDeepEqualErr(v{{$i}}v3, v{{$i}}v4, t, "equal-slice-v{{$i}}-custom")
     v{{$i}}v2 = nil
-    bs{{$i}}, _ = testMarshalErr(&v{{$i}}v3, h, t, "-")
+    bs{{$i}}, _ = testMarshalErr(&v{{$i}}v3, h, t, "enc-slice-v{{$i}}-custom-p")
     v{{$i}}v4 = {{ .MethodNamePfx "type" false }}(v{{$i}}v2)
-    testUnmarshalErr(&v{{$i}}v4, bs{{$i}}, h, t, "-")
-    testDeepEqualErr(v{{$i}}v3, v{{$i}}v4, t, "-")
+    testUnmarshalErr(&v{{$i}}v4, bs{{$i}}, h, t, "dec-slice-v{{$i}}-custom-p")
+    testDeepEqualErr(v{{$i}}v3, v{{$i}}v4, t, "equal-slice-v{{$i}}-custom-p")
+    }
 {{end}}{{end}}{{end}}
 }
 
 func doTestMammothMaps(t *testing.T, h Handle) {
 {{range $i, $e := .Values }}{{if not .Primitive }}{{if .MapKey }}{{/*
 */}}
-	v{{$i}}v1 := map[{{ .MapKey }}]{{ .Elem }}{ {{ nonzerocmd .MapKey }}:{{ nonzerocmd .Elem }} }
-	bs{{$i}}, _ := testMarshalErr(v{{$i}}v1, h, t, "-")
-	v{{$i}}v2 := make(map[{{ .MapKey }}]{{ .Elem }})
-	testUnmarshalErr(v{{$i}}v2, bs{{$i}}, h, t, "-")
-	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "-")
-	bs{{$i}}, _ = testMarshalErr(&v{{$i}}v1, h, t, "-")
+    for _, v := range []map[{{ .MapKey }}]{{ .Elem }}{ nil, map[{{ .MapKey }}]{{ .Elem }}{}, map[{{ .MapKey }}]{{ .Elem }}{ {{ nonzerocmd .MapKey }}:{{ nonzerocmd .Elem }} } } {
+    // fmt.Printf(">>>> running mammoth map v{{$i}}: %v\n", v)
+    var v{{$i}}v1, v{{$i}}v2 map[{{ .MapKey }}]{{ .Elem }}
+	v{{$i}}v1 = v
+	bs{{$i}}, _ := testMarshalErr(v{{$i}}v1, h, t, "enc-map-v{{$i}}")
+    if v != nil { v{{$i}}v2 = make(map[{{ .MapKey }}]{{ .Elem }}, len(v)) }
+	testUnmarshalErr(v{{$i}}v2, bs{{$i}}, h, t, "dec-map-v{{$i}}")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-map-v{{$i}}")
+	bs{{$i}}, _ = testMarshalErr(&v{{$i}}v1, h, t, "enc-map-v{{$i}}-p")
 	v{{$i}}v2 = nil
-	testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "-")
-	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "-")
+	testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-map-v{{$i}}-p")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-map-v{{$i}}-p")
+    }
 {{end}}{{end}}{{end}}
 
 }

codec/mammoth_generated_test.go

@@ -9,12 +9,15 @@
 package codec
 
 import "testing"
+import "fmt"
 
 // TestMammoth has all the different paths optimized in fast-path
 // It has all the primitives, slices and maps.
 //
 // For each of those types, it has a pointer and a non-pointer field.
 
+func init() { _ = fmt.Printf } // so we can include fmt as needed
+
 type TestMammoth struct {
 	FIntf       interface{}
 	FptrIntf    *interface{}
@@ -656,2899 +659,4570 @@ func (_ typeSliceBool) MapBySlice() {}
 
 func doTestMammothSlices(t *testing.T, h Handle) {
 
-	v1v1 := []interface{}{"string-is-an-interface", "string-is-an-interface"}
-	bs1, _ := testMarshalErr(v1v1, h, t, "-")
-	v1v2 := make([]interface{}, 2)
-	testUnmarshalErr(v1v2, bs1, h, t, "-")
-	testDeepEqualErr(v1v1, v1v2, t, "-")
-	bs1, _ = testMarshalErr(&v1v1, h, t, "-")
-	v1v2 = nil
-	testUnmarshalErr(&v1v2, bs1, h, t, "-")
-	testDeepEqualErr(v1v1, v1v2, t, "-")
-	// ...
-	v1v2 = make([]interface{}, 2)
-	v1v3 := typeSliceIntf(v1v1)
-	bs1, _ = testMarshalErr(v1v3, h, t, "-")
-	v1v4 := typeSliceIntf(v1v2)
-	testUnmarshalErr(v1v4, bs1, h, t, "-")
-	testDeepEqualErr(v1v3, v1v4, t, "-")
-	v1v2 = nil
-	bs1, _ = testMarshalErr(&v1v3, h, t, "-")
-	v1v4 = typeSliceIntf(v1v2)
-	testUnmarshalErr(&v1v4, bs1, h, t, "-")
-	testDeepEqualErr(v1v3, v1v4, t, "-")
-
-	v19v1 := []string{"some-string", "some-string"}
-	bs19, _ := testMarshalErr(v19v1, h, t, "-")
-	v19v2 := make([]string, 2)
-	testUnmarshalErr(v19v2, bs19, h, t, "-")
-	testDeepEqualErr(v19v1, v19v2, t, "-")
-	bs19, _ = testMarshalErr(&v19v1, h, t, "-")
-	v19v2 = nil
-	testUnmarshalErr(&v19v2, bs19, h, t, "-")
-	testDeepEqualErr(v19v1, v19v2, t, "-")
-	// ...
-	v19v2 = make([]string, 2)
-	v19v3 := typeSliceString(v19v1)
-	bs19, _ = testMarshalErr(v19v3, h, t, "-")
-	v19v4 := typeSliceString(v19v2)
-	testUnmarshalErr(v19v4, bs19, h, t, "-")
-	testDeepEqualErr(v19v3, v19v4, t, "-")
-	v19v2 = nil
-	bs19, _ = testMarshalErr(&v19v3, h, t, "-")
-	v19v4 = typeSliceString(v19v2)
-	testUnmarshalErr(&v19v4, bs19, h, t, "-")
-	testDeepEqualErr(v19v3, v19v4, t, "-")
-
-	v37v1 := []float32{10.1, 10.1}
-	bs37, _ := testMarshalErr(v37v1, h, t, "-")
-	v37v2 := make([]float32, 2)
-	testUnmarshalErr(v37v2, bs37, h, t, "-")
-	testDeepEqualErr(v37v1, v37v2, t, "-")
-	bs37, _ = testMarshalErr(&v37v1, h, t, "-")
-	v37v2 = nil
-	testUnmarshalErr(&v37v2, bs37, h, t, "-")
-	testDeepEqualErr(v37v1, v37v2, t, "-")
-	// ...
-	v37v2 = make([]float32, 2)
-	v37v3 := typeSliceFloat32(v37v1)
-	bs37, _ = testMarshalErr(v37v3, h, t, "-")
-	v37v4 := typeSliceFloat32(v37v2)
-	testUnmarshalErr(v37v4, bs37, h, t, "-")
-	testDeepEqualErr(v37v3, v37v4, t, "-")
-	v37v2 = nil
-	bs37, _ = testMarshalErr(&v37v3, h, t, "-")
-	v37v4 = typeSliceFloat32(v37v2)
-	testUnmarshalErr(&v37v4, bs37, h, t, "-")
-	testDeepEqualErr(v37v3, v37v4, t, "-")
-
-	v55v1 := []float64{10.1, 10.1}
-	bs55, _ := testMarshalErr(v55v1, h, t, "-")
-	v55v2 := make([]float64, 2)
-	testUnmarshalErr(v55v2, bs55, h, t, "-")
-	testDeepEqualErr(v55v1, v55v2, t, "-")
-	bs55, _ = testMarshalErr(&v55v1, h, t, "-")
-	v55v2 = nil
-	testUnmarshalErr(&v55v2, bs55, h, t, "-")
-	testDeepEqualErr(v55v1, v55v2, t, "-")
-	// ...
-	v55v2 = make([]float64, 2)
-	v55v3 := typeSliceFloat64(v55v1)
-	bs55, _ = testMarshalErr(v55v3, h, t, "-")
-	v55v4 := typeSliceFloat64(v55v2)
-	testUnmarshalErr(v55v4, bs55, h, t, "-")
-	testDeepEqualErr(v55v3, v55v4, t, "-")
-	v55v2 = nil
-	bs55, _ = testMarshalErr(&v55v3, h, t, "-")
-	v55v4 = typeSliceFloat64(v55v2)
-	testUnmarshalErr(&v55v4, bs55, h, t, "-")
-	testDeepEqualErr(v55v3, v55v4, t, "-")
-
-	v73v1 := []uint{10, 10}
-	bs73, _ := testMarshalErr(v73v1, h, t, "-")
-	v73v2 := make([]uint, 2)
-	testUnmarshalErr(v73v2, bs73, h, t, "-")
-	testDeepEqualErr(v73v1, v73v2, t, "-")
-	bs73, _ = testMarshalErr(&v73v1, h, t, "-")
-	v73v2 = nil
-	testUnmarshalErr(&v73v2, bs73, h, t, "-")
-	testDeepEqualErr(v73v1, v73v2, t, "-")
-	// ...
-	v73v2 = make([]uint, 2)
-	v73v3 := typeSliceUint(v73v1)
-	bs73, _ = testMarshalErr(v73v3, h, t, "-")
-	v73v4 := typeSliceUint(v73v2)
-	testUnmarshalErr(v73v4, bs73, h, t, "-")
-	testDeepEqualErr(v73v3, v73v4, t, "-")
-	v73v2 = nil
-	bs73, _ = testMarshalErr(&v73v3, h, t, "-")
-	v73v4 = typeSliceUint(v73v2)
-	testUnmarshalErr(&v73v4, bs73, h, t, "-")
-	testDeepEqualErr(v73v3, v73v4, t, "-")
-
-	v108v1 := []uint16{10, 10}
-	bs108, _ := testMarshalErr(v108v1, h, t, "-")
-	v108v2 := make([]uint16, 2)
-	testUnmarshalErr(v108v2, bs108, h, t, "-")
-	testDeepEqualErr(v108v1, v108v2, t, "-")
-	bs108, _ = testMarshalErr(&v108v1, h, t, "-")
-	v108v2 = nil
-	testUnmarshalErr(&v108v2, bs108, h, t, "-")
-	testDeepEqualErr(v108v1, v108v2, t, "-")
-	// ...
-	v108v2 = make([]uint16, 2)
-	v108v3 := typeSliceUint16(v108v1)
-	bs108, _ = testMarshalErr(v108v3, h, t, "-")
-	v108v4 := typeSliceUint16(v108v2)
-	testUnmarshalErr(v108v4, bs108, h, t, "-")
-	testDeepEqualErr(v108v3, v108v4, t, "-")
-	v108v2 = nil
-	bs108, _ = testMarshalErr(&v108v3, h, t, "-")
-	v108v4 = typeSliceUint16(v108v2)
-	testUnmarshalErr(&v108v4, bs108, h, t, "-")
-	testDeepEqualErr(v108v3, v108v4, t, "-")
-
-	v126v1 := []uint32{10, 10}
-	bs126, _ := testMarshalErr(v126v1, h, t, "-")
-	v126v2 := make([]uint32, 2)
-	testUnmarshalErr(v126v2, bs126, h, t, "-")
-	testDeepEqualErr(v126v1, v126v2, t, "-")
-	bs126, _ = testMarshalErr(&v126v1, h, t, "-")
-	v126v2 = nil
-	testUnmarshalErr(&v126v2, bs126, h, t, "-")
-	testDeepEqualErr(v126v1, v126v2, t, "-")
-	// ...
-	v126v2 = make([]uint32, 2)
-	v126v3 := typeSliceUint32(v126v1)
-	bs126, _ = testMarshalErr(v126v3, h, t, "-")
-	v126v4 := typeSliceUint32(v126v2)
-	testUnmarshalErr(v126v4, bs126, h, t, "-")
-	testDeepEqualErr(v126v3, v126v4, t, "-")
-	v126v2 = nil
-	bs126, _ = testMarshalErr(&v126v3, h, t, "-")
-	v126v4 = typeSliceUint32(v126v2)
-	testUnmarshalErr(&v126v4, bs126, h, t, "-")
-	testDeepEqualErr(v126v3, v126v4, t, "-")
-
-	v144v1 := []uint64{10, 10}
-	bs144, _ := testMarshalErr(v144v1, h, t, "-")
-	v144v2 := make([]uint64, 2)
-	testUnmarshalErr(v144v2, bs144, h, t, "-")
-	testDeepEqualErr(v144v1, v144v2, t, "-")
-	bs144, _ = testMarshalErr(&v144v1, h, t, "-")
-	v144v2 = nil
-	testUnmarshalErr(&v144v2, bs144, h, t, "-")
-	testDeepEqualErr(v144v1, v144v2, t, "-")
-	// ...
-	v144v2 = make([]uint64, 2)
-	v144v3 := typeSliceUint64(v144v1)
-	bs144, _ = testMarshalErr(v144v3, h, t, "-")
-	v144v4 := typeSliceUint64(v144v2)
-	testUnmarshalErr(v144v4, bs144, h, t, "-")
-	testDeepEqualErr(v144v3, v144v4, t, "-")
-	v144v2 = nil
-	bs144, _ = testMarshalErr(&v144v3, h, t, "-")
-	v144v4 = typeSliceUint64(v144v2)
-	testUnmarshalErr(&v144v4, bs144, h, t, "-")
-	testDeepEqualErr(v144v3, v144v4, t, "-")
-
-	v162v1 := []uintptr{10, 10}
-	bs162, _ := testMarshalErr(v162v1, h, t, "-")
-	v162v2 := make([]uintptr, 2)
-	testUnmarshalErr(v162v2, bs162, h, t, "-")
-	testDeepEqualErr(v162v1, v162v2, t, "-")
-	bs162, _ = testMarshalErr(&v162v1, h, t, "-")
-	v162v2 = nil
-	testUnmarshalErr(&v162v2, bs162, h, t, "-")
-	testDeepEqualErr(v162v1, v162v2, t, "-")
-	// ...
-	v162v2 = make([]uintptr, 2)
-	v162v3 := typeSliceUintptr(v162v1)
-	bs162, _ = testMarshalErr(v162v3, h, t, "-")
-	v162v4 := typeSliceUintptr(v162v2)
-	testUnmarshalErr(v162v4, bs162, h, t, "-")
-	testDeepEqualErr(v162v3, v162v4, t, "-")
-	v162v2 = nil
-	bs162, _ = testMarshalErr(&v162v3, h, t, "-")
-	v162v4 = typeSliceUintptr(v162v2)
-	testUnmarshalErr(&v162v4, bs162, h, t, "-")
-	testDeepEqualErr(v162v3, v162v4, t, "-")
-
-	v180v1 := []int{10, 10}
-	bs180, _ := testMarshalErr(v180v1, h, t, "-")
-	v180v2 := make([]int, 2)
-	testUnmarshalErr(v180v2, bs180, h, t, "-")
-	testDeepEqualErr(v180v1, v180v2, t, "-")
-	bs180, _ = testMarshalErr(&v180v1, h, t, "-")
-	v180v2 = nil
-	testUnmarshalErr(&v180v2, bs180, h, t, "-")
-	testDeepEqualErr(v180v1, v180v2, t, "-")
-	// ...
-	v180v2 = make([]int, 2)
-	v180v3 := typeSliceInt(v180v1)
-	bs180, _ = testMarshalErr(v180v3, h, t, "-")
-	v180v4 := typeSliceInt(v180v2)
-	testUnmarshalErr(v180v4, bs180, h, t, "-")
-	testDeepEqualErr(v180v3, v180v4, t, "-")
-	v180v2 = nil
-	bs180, _ = testMarshalErr(&v180v3, h, t, "-")
-	v180v4 = typeSliceInt(v180v2)
-	testUnmarshalErr(&v180v4, bs180, h, t, "-")
-	testDeepEqualErr(v180v3, v180v4, t, "-")
-
-	v198v1 := []int8{10, 10}
-	bs198, _ := testMarshalErr(v198v1, h, t, "-")
-	v198v2 := make([]int8, 2)
-	testUnmarshalErr(v198v2, bs198, h, t, "-")
-	testDeepEqualErr(v198v1, v198v2, t, "-")
-	bs198, _ = testMarshalErr(&v198v1, h, t, "-")
-	v198v2 = nil
-	testUnmarshalErr(&v198v2, bs198, h, t, "-")
-	testDeepEqualErr(v198v1, v198v2, t, "-")
-	// ...
-	v198v2 = make([]int8, 2)
-	v198v3 := typeSliceInt8(v198v1)
-	bs198, _ = testMarshalErr(v198v3, h, t, "-")
-	v198v4 := typeSliceInt8(v198v2)
-	testUnmarshalErr(v198v4, bs198, h, t, "-")
-	testDeepEqualErr(v198v3, v198v4, t, "-")
-	v198v2 = nil
-	bs198, _ = testMarshalErr(&v198v3, h, t, "-")
-	v198v4 = typeSliceInt8(v198v2)
-	testUnmarshalErr(&v198v4, bs198, h, t, "-")
-	testDeepEqualErr(v198v3, v198v4, t, "-")
-
-	v216v1 := []int16{10, 10}
-	bs216, _ := testMarshalErr(v216v1, h, t, "-")
-	v216v2 := make([]int16, 2)
-	testUnmarshalErr(v216v2, bs216, h, t, "-")
-	testDeepEqualErr(v216v1, v216v2, t, "-")
-	bs216, _ = testMarshalErr(&v216v1, h, t, "-")
-	v216v2 = nil
-	testUnmarshalErr(&v216v2, bs216, h, t, "-")
-	testDeepEqualErr(v216v1, v216v2, t, "-")
-	// ...
-	v216v2 = make([]int16, 2)
-	v216v3 := typeSliceInt16(v216v1)
-	bs216, _ = testMarshalErr(v216v3, h, t, "-")
-	v216v4 := typeSliceInt16(v216v2)
-	testUnmarshalErr(v216v4, bs216, h, t, "-")
-	testDeepEqualErr(v216v3, v216v4, t, "-")
-	v216v2 = nil
-	bs216, _ = testMarshalErr(&v216v3, h, t, "-")
-	v216v4 = typeSliceInt16(v216v2)
-	testUnmarshalErr(&v216v4, bs216, h, t, "-")
-	testDeepEqualErr(v216v3, v216v4, t, "-")
-
-	v234v1 := []int32{10, 10}
-	bs234, _ := testMarshalErr(v234v1, h, t, "-")
-	v234v2 := make([]int32, 2)
-	testUnmarshalErr(v234v2, bs234, h, t, "-")
-	testDeepEqualErr(v234v1, v234v2, t, "-")
-	bs234, _ = testMarshalErr(&v234v1, h, t, "-")
-	v234v2 = nil
-	testUnmarshalErr(&v234v2, bs234, h, t, "-")
-	testDeepEqualErr(v234v1, v234v2, t, "-")
-	// ...
-	v234v2 = make([]int32, 2)
-	v234v3 := typeSliceInt32(v234v1)
-	bs234, _ = testMarshalErr(v234v3, h, t, "-")
-	v234v4 := typeSliceInt32(v234v2)
-	testUnmarshalErr(v234v4, bs234, h, t, "-")
-	testDeepEqualErr(v234v3, v234v4, t, "-")
-	v234v2 = nil
-	bs234, _ = testMarshalErr(&v234v3, h, t, "-")
-	v234v4 = typeSliceInt32(v234v2)
-	testUnmarshalErr(&v234v4, bs234, h, t, "-")
-	testDeepEqualErr(v234v3, v234v4, t, "-")
-
-	v252v1 := []int64{10, 10}
-	bs252, _ := testMarshalErr(v252v1, h, t, "-")
-	v252v2 := make([]int64, 2)
-	testUnmarshalErr(v252v2, bs252, h, t, "-")
-	testDeepEqualErr(v252v1, v252v2, t, "-")
-	bs252, _ = testMarshalErr(&v252v1, h, t, "-")
-	v252v2 = nil
-	testUnmarshalErr(&v252v2, bs252, h, t, "-")
-	testDeepEqualErr(v252v1, v252v2, t, "-")
-	// ...
-	v252v2 = make([]int64, 2)
-	v252v3 := typeSliceInt64(v252v1)
-	bs252, _ = testMarshalErr(v252v3, h, t, "-")
-	v252v4 := typeSliceInt64(v252v2)
-	testUnmarshalErr(v252v4, bs252, h, t, "-")
-	testDeepEqualErr(v252v3, v252v4, t, "-")
-	v252v2 = nil
-	bs252, _ = testMarshalErr(&v252v3, h, t, "-")
-	v252v4 = typeSliceInt64(v252v2)
-	testUnmarshalErr(&v252v4, bs252, h, t, "-")
-	testDeepEqualErr(v252v3, v252v4, t, "-")
-
-	v270v1 := []bool{true, true}
-	bs270, _ := testMarshalErr(v270v1, h, t, "-")
-	v270v2 := make([]bool, 2)
-	testUnmarshalErr(v270v2, bs270, h, t, "-")
-	testDeepEqualErr(v270v1, v270v2, t, "-")
-	bs270, _ = testMarshalErr(&v270v1, h, t, "-")
-	v270v2 = nil
-	testUnmarshalErr(&v270v2, bs270, h, t, "-")
-	testDeepEqualErr(v270v1, v270v2, t, "-")
-	// ...
-	v270v2 = make([]bool, 2)
-	v270v3 := typeSliceBool(v270v1)
-	bs270, _ = testMarshalErr(v270v3, h, t, "-")
-	v270v4 := typeSliceBool(v270v2)
-	testUnmarshalErr(v270v4, bs270, h, t, "-")
-	testDeepEqualErr(v270v3, v270v4, t, "-")
-	v270v2 = nil
-	bs270, _ = testMarshalErr(&v270v3, h, t, "-")
-	v270v4 = typeSliceBool(v270v2)
-	testUnmarshalErr(&v270v4, bs270, h, t, "-")
-	testDeepEqualErr(v270v3, v270v4, t, "-")
+	for _, v := range [][]interface{}{nil, []interface{}{}, []interface{}{"string-is-an-interface", "string-is-an-interface"}} {
+		// fmt.Printf(">>>> running mammoth slice v1: %v\n", v)
+		var v1v1, v1v2, v1v3, v1v4 []interface{}
+		v1v1 = v
+		bs1, _ := testMarshalErr(v1v1, h, t, "enc-slice-v1")
+		if v != nil {
+			v1v2 = make([]interface{}, len(v))
+		}
+		testUnmarshalErr(v1v2, bs1, h, t, "dec-slice-v1")
+		testDeepEqualErr(v1v1, v1v2, t, "equal-slice-v1")
+		bs1, _ = testMarshalErr(&v1v1, h, t, "enc-slice-v1-p")
+		v1v2 = nil
+		testUnmarshalErr(&v1v2, bs1, h, t, "dec-slice-v1-p")
+		testDeepEqualErr(v1v1, v1v2, t, "equal-slice-v1-p")
+		// ...
+		v1v2 = nil
+		if v != nil {
+			v1v2 = make([]interface{}, len(v))
+		}
+		v1v3 = typeSliceIntf(v1v1)
+		bs1, _ = testMarshalErr(v1v3, h, t, "enc-slice-v1-custom")
+		v1v4 = typeSliceIntf(v1v2)
+		testUnmarshalErr(v1v4, bs1, h, t, "dec-slice-v1-custom")
+		testDeepEqualErr(v1v3, v1v4, t, "equal-slice-v1-custom")
+		v1v2 = nil
+		bs1, _ = testMarshalErr(&v1v3, h, t, "enc-slice-v1-custom-p")
+		v1v4 = typeSliceIntf(v1v2)
+		testUnmarshalErr(&v1v4, bs1, h, t, "dec-slice-v1-custom-p")
+		testDeepEqualErr(v1v3, v1v4, t, "equal-slice-v1-custom-p")
+	}
+
+	for _, v := range [][]string{nil, []string{}, []string{"some-string", "some-string"}} {
+		// fmt.Printf(">>>> running mammoth slice v19: %v\n", v)
+		var v19v1, v19v2, v19v3, v19v4 []string
+		v19v1 = v
+		bs19, _ := testMarshalErr(v19v1, h, t, "enc-slice-v19")
+		if v != nil {
+			v19v2 = make([]string, len(v))
+		}
+		testUnmarshalErr(v19v2, bs19, h, t, "dec-slice-v19")
+		testDeepEqualErr(v19v1, v19v2, t, "equal-slice-v19")
+		bs19, _ = testMarshalErr(&v19v1, h, t, "enc-slice-v19-p")
+		v19v2 = nil
+		testUnmarshalErr(&v19v2, bs19, h, t, "dec-slice-v19-p")
+		testDeepEqualErr(v19v1, v19v2, t, "equal-slice-v19-p")
+		// ...
+		v19v2 = nil
+		if v != nil {
+			v19v2 = make([]string, len(v))
+		}
+		v19v3 = typeSliceString(v19v1)
+		bs19, _ = testMarshalErr(v19v3, h, t, "enc-slice-v19-custom")
+		v19v4 = typeSliceString(v19v2)
+		testUnmarshalErr(v19v4, bs19, h, t, "dec-slice-v19-custom")
+		testDeepEqualErr(v19v3, v19v4, t, "equal-slice-v19-custom")
+		v19v2 = nil
+		bs19, _ = testMarshalErr(&v19v3, h, t, "enc-slice-v19-custom-p")
+		v19v4 = typeSliceString(v19v2)
+		testUnmarshalErr(&v19v4, bs19, h, t, "dec-slice-v19-custom-p")
+		testDeepEqualErr(v19v3, v19v4, t, "equal-slice-v19-custom-p")
+	}
+
+	for _, v := range [][]float32{nil, []float32{}, []float32{10.1, 10.1}} {
+		// fmt.Printf(">>>> running mammoth slice v37: %v\n", v)
+		var v37v1, v37v2, v37v3, v37v4 []float32
+		v37v1 = v
+		bs37, _ := testMarshalErr(v37v1, h, t, "enc-slice-v37")
+		if v != nil {
+			v37v2 = make([]float32, len(v))
+		}
+		testUnmarshalErr(v37v2, bs37, h, t, "dec-slice-v37")
+		testDeepEqualErr(v37v1, v37v2, t, "equal-slice-v37")
+		bs37, _ = testMarshalErr(&v37v1, h, t, "enc-slice-v37-p")
+		v37v2 = nil
+		testUnmarshalErr(&v37v2, bs37, h, t, "dec-slice-v37-p")
+		testDeepEqualErr(v37v1, v37v2, t, "equal-slice-v37-p")
+		// ...
+		v37v2 = nil
+		if v != nil {
+			v37v2 = make([]float32, len(v))
+		}
+		v37v3 = typeSliceFloat32(v37v1)
+		bs37, _ = testMarshalErr(v37v3, h, t, "enc-slice-v37-custom")
+		v37v4 = typeSliceFloat32(v37v2)
+		testUnmarshalErr(v37v4, bs37, h, t, "dec-slice-v37-custom")
+		testDeepEqualErr(v37v3, v37v4, t, "equal-slice-v37-custom")
+		v37v2 = nil
+		bs37, _ = testMarshalErr(&v37v3, h, t, "enc-slice-v37-custom-p")
+		v37v4 = typeSliceFloat32(v37v2)
+		testUnmarshalErr(&v37v4, bs37, h, t, "dec-slice-v37-custom-p")
+		testDeepEqualErr(v37v3, v37v4, t, "equal-slice-v37-custom-p")
+	}
+
+	for _, v := range [][]float64{nil, []float64{}, []float64{10.1, 10.1}} {
+		// fmt.Printf(">>>> running mammoth slice v55: %v\n", v)
+		var v55v1, v55v2, v55v3, v55v4 []float64
+		v55v1 = v
+		bs55, _ := testMarshalErr(v55v1, h, t, "enc-slice-v55")
+		if v != nil {
+			v55v2 = make([]float64, len(v))
+		}
+		testUnmarshalErr(v55v2, bs55, h, t, "dec-slice-v55")
+		testDeepEqualErr(v55v1, v55v2, t, "equal-slice-v55")
+		bs55, _ = testMarshalErr(&v55v1, h, t, "enc-slice-v55-p")
+		v55v2 = nil
+		testUnmarshalErr(&v55v2, bs55, h, t, "dec-slice-v55-p")
+		testDeepEqualErr(v55v1, v55v2, t, "equal-slice-v55-p")
+		// ...
+		v55v2 = nil
+		if v != nil {
+			v55v2 = make([]float64, len(v))
+		}
+		v55v3 = typeSliceFloat64(v55v1)
+		bs55, _ = testMarshalErr(v55v3, h, t, "enc-slice-v55-custom")
+		v55v4 = typeSliceFloat64(v55v2)
+		testUnmarshalErr(v55v4, bs55, h, t, "dec-slice-v55-custom")
+		testDeepEqualErr(v55v3, v55v4, t, "equal-slice-v55-custom")
+		v55v2 = nil
+		bs55, _ = testMarshalErr(&v55v3, h, t, "enc-slice-v55-custom-p")
+		v55v4 = typeSliceFloat64(v55v2)
+		testUnmarshalErr(&v55v4, bs55, h, t, "dec-slice-v55-custom-p")
+		testDeepEqualErr(v55v3, v55v4, t, "equal-slice-v55-custom-p")
+	}
+
+	for _, v := range [][]uint{nil, []uint{}, []uint{10, 10}} {
+		// fmt.Printf(">>>> running mammoth slice v73: %v\n", v)
+		var v73v1, v73v2, v73v3, v73v4 []uint
+		v73v1 = v
+		bs73, _ := testMarshalErr(v73v1, h, t, "enc-slice-v73")
+		if v != nil {
+			v73v2 = make([]uint, len(v))
+		}
+		testUnmarshalErr(v73v2, bs73, h, t, "dec-slice-v73")
+		testDeepEqualErr(v73v1, v73v2, t, "equal-slice-v73")
+		bs73, _ = testMarshalErr(&v73v1, h, t, "enc-slice-v73-p")
+		v73v2 = nil
+		testUnmarshalErr(&v73v2, bs73, h, t, "dec-slice-v73-p")
+		testDeepEqualErr(v73v1, v73v2, t, "equal-slice-v73-p")
+		// ...
+		v73v2 = nil
+		if v != nil {
+			v73v2 = make([]uint, len(v))
+		}
+		v73v3 = typeSliceUint(v73v1)
+		bs73, _ = testMarshalErr(v73v3, h, t, "enc-slice-v73-custom")
+		v73v4 = typeSliceUint(v73v2)
+		testUnmarshalErr(v73v4, bs73, h, t, "dec-slice-v73-custom")
+		testDeepEqualErr(v73v3, v73v4, t, "equal-slice-v73-custom")
+		v73v2 = nil
+		bs73, _ = testMarshalErr(&v73v3, h, t, "enc-slice-v73-custom-p")
+		v73v4 = typeSliceUint(v73v2)
+		testUnmarshalErr(&v73v4, bs73, h, t, "dec-slice-v73-custom-p")
+		testDeepEqualErr(v73v3, v73v4, t, "equal-slice-v73-custom-p")
+	}
+
+	for _, v := range [][]uint16{nil, []uint16{}, []uint16{10, 10}} {
+		// fmt.Printf(">>>> running mammoth slice v108: %v\n", v)
+		var v108v1, v108v2, v108v3, v108v4 []uint16
+		v108v1 = v
+		bs108, _ := testMarshalErr(v108v1, h, t, "enc-slice-v108")
+		if v != nil {
+			v108v2 = make([]uint16, len(v))
+		}
+		testUnmarshalErr(v108v2, bs108, h, t, "dec-slice-v108")
+		testDeepEqualErr(v108v1, v108v2, t, "equal-slice-v108")
+		bs108, _ = testMarshalErr(&v108v1, h, t, "enc-slice-v108-p")
+		v108v2 = nil
+		testUnmarshalErr(&v108v2, bs108, h, t, "dec-slice-v108-p")
+		testDeepEqualErr(v108v1, v108v2, t, "equal-slice-v108-p")
+		// ...
+		v108v2 = nil
+		if v != nil {
+			v108v2 = make([]uint16, len(v))
+		}
+		v108v3 = typeSliceUint16(v108v1)
+		bs108, _ = testMarshalErr(v108v3, h, t, "enc-slice-v108-custom")
+		v108v4 = typeSliceUint16(v108v2)
+		testUnmarshalErr(v108v4, bs108, h, t, "dec-slice-v108-custom")
+		testDeepEqualErr(v108v3, v108v4, t, "equal-slice-v108-custom")
+		v108v2 = nil
+		bs108, _ = testMarshalErr(&v108v3, h, t, "enc-slice-v108-custom-p")
+		v108v4 = typeSliceUint16(v108v2)
+		testUnmarshalErr(&v108v4, bs108, h, t, "dec-slice-v108-custom-p")
+		testDeepEqualErr(v108v3, v108v4, t, "equal-slice-v108-custom-p")
+	}
+
+	for _, v := range [][]uint32{nil, []uint32{}, []uint32{10, 10}} {
+		// fmt.Printf(">>>> running mammoth slice v126: %v\n", v)
+		var v126v1, v126v2, v126v3, v126v4 []uint32
+		v126v1 = v
+		bs126, _ := testMarshalErr(v126v1, h, t, "enc-slice-v126")
+		if v != nil {
+			v126v2 = make([]uint32, len(v))
+		}
+		testUnmarshalErr(v126v2, bs126, h, t, "dec-slice-v126")
+		testDeepEqualErr(v126v1, v126v2, t, "equal-slice-v126")
+		bs126, _ = testMarshalErr(&v126v1, h, t, "enc-slice-v126-p")
+		v126v2 = nil
+		testUnmarshalErr(&v126v2, bs126, h, t, "dec-slice-v126-p")
+		testDeepEqualErr(v126v1, v126v2, t, "equal-slice-v126-p")
+		// ...
+		v126v2 = nil
+		if v != nil {
+			v126v2 = make([]uint32, len(v))
+		}
+		v126v3 = typeSliceUint32(v126v1)
+		bs126, _ = testMarshalErr(v126v3, h, t, "enc-slice-v126-custom")
+		v126v4 = typeSliceUint32(v126v2)
+		testUnmarshalErr(v126v4, bs126, h, t, "dec-slice-v126-custom")
+		testDeepEqualErr(v126v3, v126v4, t, "equal-slice-v126-custom")
+		v126v2 = nil
+		bs126, _ = testMarshalErr(&v126v3, h, t, "enc-slice-v126-custom-p")
+		v126v4 = typeSliceUint32(v126v2)
+		testUnmarshalErr(&v126v4, bs126, h, t, "dec-slice-v126-custom-p")
+		testDeepEqualErr(v126v3, v126v4, t, "equal-slice-v126-custom-p")
+	}
+
+	for _, v := range [][]uint64{nil, []uint64{}, []uint64{10, 10}} {
+		// fmt.Printf(">>>> running mammoth slice v144: %v\n", v)
+		var v144v1, v144v2, v144v3, v144v4 []uint64
+		v144v1 = v
+		bs144, _ := testMarshalErr(v144v1, h, t, "enc-slice-v144")
+		if v != nil {
+			v144v2 = make([]uint64, len(v))
+		}
+		testUnmarshalErr(v144v2, bs144, h, t, "dec-slice-v144")
+		testDeepEqualErr(v144v1, v144v2, t, "equal-slice-v144")
+		bs144, _ = testMarshalErr(&v144v1, h, t, "enc-slice-v144-p")
+		v144v2 = nil
+		testUnmarshalErr(&v144v2, bs144, h, t, "dec-slice-v144-p")
+		testDeepEqualErr(v144v1, v144v2, t, "equal-slice-v144-p")
+		// ...
+		v144v2 = nil
+		if v != nil {
+			v144v2 = make([]uint64, len(v))
+		}
+		v144v3 = typeSliceUint64(v144v1)
+		bs144, _ = testMarshalErr(v144v3, h, t, "enc-slice-v144-custom")
+		v144v4 = typeSliceUint64(v144v2)
+		testUnmarshalErr(v144v4, bs144, h, t, "dec-slice-v144-custom")
+		testDeepEqualErr(v144v3, v144v4, t, "equal-slice-v144-custom")
+		v144v2 = nil
+		bs144, _ = testMarshalErr(&v144v3, h, t, "enc-slice-v144-custom-p")
+		v144v4 = typeSliceUint64(v144v2)
+		testUnmarshalErr(&v144v4, bs144, h, t, "dec-slice-v144-custom-p")
+		testDeepEqualErr(v144v3, v144v4, t, "equal-slice-v144-custom-p")
+	}
+
+	for _, v := range [][]uintptr{nil, []uintptr{}, []uintptr{10, 10}} {
+		// fmt.Printf(">>>> running mammoth slice v162: %v\n", v)
+		var v162v1, v162v2, v162v3, v162v4 []uintptr
+		v162v1 = v
+		bs162, _ := testMarshalErr(v162v1, h, t, "enc-slice-v162")
+		if v != nil {
+			v162v2 = make([]uintptr, len(v))
+		}
+		testUnmarshalErr(v162v2, bs162, h, t, "dec-slice-v162")
+		testDeepEqualErr(v162v1, v162v2, t, "equal-slice-v162")
+		bs162, _ = testMarshalErr(&v162v1, h, t, "enc-slice-v162-p")
+		v162v2 = nil
+		testUnmarshalErr(&v162v2, bs162, h, t, "dec-slice-v162-p")
+		testDeepEqualErr(v162v1, v162v2, t, "equal-slice-v162-p")
+		// ...
+		v162v2 = nil
+		if v != nil {
+			v162v2 = make([]uintptr, len(v))
+		}
+		v162v3 = typeSliceUintptr(v162v1)
+		bs162, _ = testMarshalErr(v162v3, h, t, "enc-slice-v162-custom")
+		v162v4 = typeSliceUintptr(v162v2)
+		testUnmarshalErr(v162v4, bs162, h, t, "dec-slice-v162-custom")
+		testDeepEqualErr(v162v3, v162v4, t, "equal-slice-v162-custom")
+		v162v2 = nil
+		bs162, _ = testMarshalErr(&v162v3, h, t, "enc-slice-v162-custom-p")
+		v162v4 = typeSliceUintptr(v162v2)
+		testUnmarshalErr(&v162v4, bs162, h, t, "dec-slice-v162-custom-p")
+		testDeepEqualErr(v162v3, v162v4, t, "equal-slice-v162-custom-p")
+	}
+
+	for _, v := range [][]int{nil, []int{}, []int{10, 10}} {
+		// fmt.Printf(">>>> running mammoth slice v180: %v\n", v)
+		var v180v1, v180v2, v180v3, v180v4 []int
+		v180v1 = v
+		bs180, _ := testMarshalErr(v180v1, h, t, "enc-slice-v180")
+		if v != nil {
+			v180v2 = make([]int, len(v))
+		}
+		testUnmarshalErr(v180v2, bs180, h, t, "dec-slice-v180")
+		testDeepEqualErr(v180v1, v180v2, t, "equal-slice-v180")
+		bs180, _ = testMarshalErr(&v180v1, h, t, "enc-slice-v180-p")
+		v180v2 = nil
+		testUnmarshalErr(&v180v2, bs180, h, t, "dec-slice-v180-p")
+		testDeepEqualErr(v180v1, v180v2, t, "equal-slice-v180-p")
+		// ...
+		v180v2 = nil
+		if v != nil {
+			v180v2 = make([]int, len(v))
+		}
+		v180v3 = typeSliceInt(v180v1)
+		bs180, _ = testMarshalErr(v180v3, h, t, "enc-slice-v180-custom")
+		v180v4 = typeSliceInt(v180v2)
+		testUnmarshalErr(v180v4, bs180, h, t, "dec-slice-v180-custom")
+		testDeepEqualErr(v180v3, v180v4, t, "equal-slice-v180-custom")
+		v180v2 = nil
+		bs180, _ = testMarshalErr(&v180v3, h, t, "enc-slice-v180-custom-p")
+		v180v4 = typeSliceInt(v180v2)
+		testUnmarshalErr(&v180v4, bs180, h, t, "dec-slice-v180-custom-p")
+		testDeepEqualErr(v180v3, v180v4, t, "equal-slice-v180-custom-p")
+	}
+
+	for _, v := range [][]int8{nil, []int8{}, []int8{10, 10}} {
+		// fmt.Printf(">>>> running mammoth slice v198: %v\n", v)
+		var v198v1, v198v2, v198v3, v198v4 []int8
+		v198v1 = v
+		bs198, _ := testMarshalErr(v198v1, h, t, "enc-slice-v198")
+		if v != nil {
+			v198v2 = make([]int8, len(v))
+		}
+		testUnmarshalErr(v198v2, bs198, h, t, "dec-slice-v198")
+		testDeepEqualErr(v198v1, v198v2, t, "equal-slice-v198")
+		bs198, _ = testMarshalErr(&v198v1, h, t, "enc-slice-v198-p")
+		v198v2 = nil
+		testUnmarshalErr(&v198v2, bs198, h, t, "dec-slice-v198-p")
+		testDeepEqualErr(v198v1, v198v2, t, "equal-slice-v198-p")
+		// ...
+		v198v2 = nil
+		if v != nil {
+			v198v2 = make([]int8, len(v))
+		}
+		v198v3 = typeSliceInt8(v198v1)
+		bs198, _ = testMarshalErr(v198v3, h, t, "enc-slice-v198-custom")
+		v198v4 = typeSliceInt8(v198v2)
+		testUnmarshalErr(v198v4, bs198, h, t, "dec-slice-v198-custom")
+		testDeepEqualErr(v198v3, v198v4, t, "equal-slice-v198-custom")
+		v198v2 = nil
+		bs198, _ = testMarshalErr(&v198v3, h, t, "enc-slice-v198-custom-p")
+		v198v4 = typeSliceInt8(v198v2)
+		testUnmarshalErr(&v198v4, bs198, h, t, "dec-slice-v198-custom-p")
+		testDeepEqualErr(v198v3, v198v4, t, "equal-slice-v198-custom-p")
+	}
+
+	for _, v := range [][]int16{nil, []int16{}, []int16{10, 10}} {
+		// fmt.Printf(">>>> running mammoth slice v216: %v\n", v)
+		var v216v1, v216v2, v216v3, v216v4 []int16
+		v216v1 = v
+		bs216, _ := testMarshalErr(v216v1, h, t, "enc-slice-v216")
+		if v != nil {
+			v216v2 = make([]int16, len(v))
+		}
+		testUnmarshalErr(v216v2, bs216, h, t, "dec-slice-v216")
+		testDeepEqualErr(v216v1, v216v2, t, "equal-slice-v216")
+		bs216, _ = testMarshalErr(&v216v1, h, t, "enc-slice-v216-p")
+		v216v2 = nil
+		testUnmarshalErr(&v216v2, bs216, h, t, "dec-slice-v216-p")
+		testDeepEqualErr(v216v1, v216v2, t, "equal-slice-v216-p")
+		// ...
+		v216v2 = nil
+		if v != nil {
+			v216v2 = make([]int16, len(v))
+		}
+		v216v3 = typeSliceInt16(v216v1)
+		bs216, _ = testMarshalErr(v216v3, h, t, "enc-slice-v216-custom")
+		v216v4 = typeSliceInt16(v216v2)
+		testUnmarshalErr(v216v4, bs216, h, t, "dec-slice-v216-custom")
+		testDeepEqualErr(v216v3, v216v4, t, "equal-slice-v216-custom")
+		v216v2 = nil
+		bs216, _ = testMarshalErr(&v216v3, h, t, "enc-slice-v216-custom-p")
+		v216v4 = typeSliceInt16(v216v2)
+		testUnmarshalErr(&v216v4, bs216, h, t, "dec-slice-v216-custom-p")
+		testDeepEqualErr(v216v3, v216v4, t, "equal-slice-v216-custom-p")
+	}
+
+	for _, v := range [][]int32{nil, []int32{}, []int32{10, 10}} {
+		// fmt.Printf(">>>> running mammoth slice v234: %v\n", v)
+		var v234v1, v234v2, v234v3, v234v4 []int32
+		v234v1 = v
+		bs234, _ := testMarshalErr(v234v1, h, t, "enc-slice-v234")
+		if v != nil {
+			v234v2 = make([]int32, len(v))
+		}
+		testUnmarshalErr(v234v2, bs234, h, t, "dec-slice-v234")
+		testDeepEqualErr(v234v1, v234v2, t, "equal-slice-v234")
+		bs234, _ = testMarshalErr(&v234v1, h, t, "enc-slice-v234-p")
+		v234v2 = nil
+		testUnmarshalErr(&v234v2, bs234, h, t, "dec-slice-v234-p")
+		testDeepEqualErr(v234v1, v234v2, t, "equal-slice-v234-p")
+		// ...
+		v234v2 = nil
+		if v != nil {
+			v234v2 = make([]int32, len(v))
+		}
+		v234v3 = typeSliceInt32(v234v1)
+		bs234, _ = testMarshalErr(v234v3, h, t, "enc-slice-v234-custom")
+		v234v4 = typeSliceInt32(v234v2)
+		testUnmarshalErr(v234v4, bs234, h, t, "dec-slice-v234-custom")
+		testDeepEqualErr(v234v3, v234v4, t, "equal-slice-v234-custom")
+		v234v2 = nil
+		bs234, _ = testMarshalErr(&v234v3, h, t, "enc-slice-v234-custom-p")
+		v234v4 = typeSliceInt32(v234v2)
+		testUnmarshalErr(&v234v4, bs234, h, t, "dec-slice-v234-custom-p")
+		testDeepEqualErr(v234v3, v234v4, t, "equal-slice-v234-custom-p")
+	}
+
+	for _, v := range [][]int64{nil, []int64{}, []int64{10, 10}} {
+		// fmt.Printf(">>>> running mammoth slice v252: %v\n", v)
+		var v252v1, v252v2, v252v3, v252v4 []int64
+		v252v1 = v
+		bs252, _ := testMarshalErr(v252v1, h, t, "enc-slice-v252")
+		if v != nil {
+			v252v2 = make([]int64, len(v))
+		}
+		testUnmarshalErr(v252v2, bs252, h, t, "dec-slice-v252")
+		testDeepEqualErr(v252v1, v252v2, t, "equal-slice-v252")
+		bs252, _ = testMarshalErr(&v252v1, h, t, "enc-slice-v252-p")
+		v252v2 = nil
+		testUnmarshalErr(&v252v2, bs252, h, t, "dec-slice-v252-p")
+		testDeepEqualErr(v252v1, v252v2, t, "equal-slice-v252-p")
+		// ...
+		v252v2 = nil
+		if v != nil {
+			v252v2 = make([]int64, len(v))
+		}
+		v252v3 = typeSliceInt64(v252v1)
+		bs252, _ = testMarshalErr(v252v3, h, t, "enc-slice-v252-custom")
+		v252v4 = typeSliceInt64(v252v2)
+		testUnmarshalErr(v252v4, bs252, h, t, "dec-slice-v252-custom")
+		testDeepEqualErr(v252v3, v252v4, t, "equal-slice-v252-custom")
+		v252v2 = nil
+		bs252, _ = testMarshalErr(&v252v3, h, t, "enc-slice-v252-custom-p")
+		v252v4 = typeSliceInt64(v252v2)
+		testUnmarshalErr(&v252v4, bs252, h, t, "dec-slice-v252-custom-p")
+		testDeepEqualErr(v252v3, v252v4, t, "equal-slice-v252-custom-p")
+	}
+
+	for _, v := range [][]bool{nil, []bool{}, []bool{true, true}} {
+		// fmt.Printf(">>>> running mammoth slice v270: %v\n", v)
+		var v270v1, v270v2, v270v3, v270v4 []bool
+		v270v1 = v
+		bs270, _ := testMarshalErr(v270v1, h, t, "enc-slice-v270")
+		if v != nil {
+			v270v2 = make([]bool, len(v))
+		}
+		testUnmarshalErr(v270v2, bs270, h, t, "dec-slice-v270")
+		testDeepEqualErr(v270v1, v270v2, t, "equal-slice-v270")
+		bs270, _ = testMarshalErr(&v270v1, h, t, "enc-slice-v270-p")
+		v270v2 = nil
+		testUnmarshalErr(&v270v2, bs270, h, t, "dec-slice-v270-p")
+		testDeepEqualErr(v270v1, v270v2, t, "equal-slice-v270-p")
+		// ...
+		v270v2 = nil
+		if v != nil {
+			v270v2 = make([]bool, len(v))
+		}
+		v270v3 = typeSliceBool(v270v1)
+		bs270, _ = testMarshalErr(v270v3, h, t, "enc-slice-v270-custom")
+		v270v4 = typeSliceBool(v270v2)
+		testUnmarshalErr(v270v4, bs270, h, t, "dec-slice-v270-custom")
+		testDeepEqualErr(v270v3, v270v4, t, "equal-slice-v270-custom")
+		v270v2 = nil
+		bs270, _ = testMarshalErr(&v270v3, h, t, "enc-slice-v270-custom-p")
+		v270v4 = typeSliceBool(v270v2)
+		testUnmarshalErr(&v270v4, bs270, h, t, "dec-slice-v270-custom-p")
+		testDeepEqualErr(v270v3, v270v4, t, "equal-slice-v270-custom-p")
+	}
 
 }
 
 func doTestMammothMaps(t *testing.T, h Handle) {
 
-	v2v1 := map[interface{}]interface{}{"string-is-an-interface": "string-is-an-interface"}
-	bs2, _ := testMarshalErr(v2v1, h, t, "-")
-	v2v2 := make(map[interface{}]interface{})
-	testUnmarshalErr(v2v2, bs2, h, t, "-")
-	testDeepEqualErr(v2v1, v2v2, t, "-")
-	bs2, _ = testMarshalErr(&v2v1, h, t, "-")
-	v2v2 = nil
-	testUnmarshalErr(&v2v2, bs2, h, t, "-")
-	testDeepEqualErr(v2v1, v2v2, t, "-")
-
-	v3v1 := map[interface{}]string{"string-is-an-interface": "some-string"}
-	bs3, _ := testMarshalErr(v3v1, h, t, "-")
-	v3v2 := make(map[interface{}]string)
-	testUnmarshalErr(v3v2, bs3, h, t, "-")
-	testDeepEqualErr(v3v1, v3v2, t, "-")
-	bs3, _ = testMarshalErr(&v3v1, h, t, "-")
-	v3v2 = nil
-	testUnmarshalErr(&v3v2, bs3, h, t, "-")
-	testDeepEqualErr(v3v1, v3v2, t, "-")
-
-	v4v1 := map[interface{}]uint{"string-is-an-interface": 10}
-	bs4, _ := testMarshalErr(v4v1, h, t, "-")
-	v4v2 := make(map[interface{}]uint)
-	testUnmarshalErr(v4v2, bs4, h, t, "-")
-	testDeepEqualErr(v4v1, v4v2, t, "-")
-	bs4, _ = testMarshalErr(&v4v1, h, t, "-")
-	v4v2 = nil
-	testUnmarshalErr(&v4v2, bs4, h, t, "-")
-	testDeepEqualErr(v4v1, v4v2, t, "-")
-
-	v5v1 := map[interface{}]uint8{"string-is-an-interface": 10}
-	bs5, _ := testMarshalErr(v5v1, h, t, "-")
-	v5v2 := make(map[interface{}]uint8)
-	testUnmarshalErr(v5v2, bs5, h, t, "-")
-	testDeepEqualErr(v5v1, v5v2, t, "-")
-	bs5, _ = testMarshalErr(&v5v1, h, t, "-")
-	v5v2 = nil
-	testUnmarshalErr(&v5v2, bs5, h, t, "-")
-	testDeepEqualErr(v5v1, v5v2, t, "-")
-
-	v6v1 := map[interface{}]uint16{"string-is-an-interface": 10}
-	bs6, _ := testMarshalErr(v6v1, h, t, "-")
-	v6v2 := make(map[interface{}]uint16)
-	testUnmarshalErr(v6v2, bs6, h, t, "-")
-	testDeepEqualErr(v6v1, v6v2, t, "-")
-	bs6, _ = testMarshalErr(&v6v1, h, t, "-")
-	v6v2 = nil
-	testUnmarshalErr(&v6v2, bs6, h, t, "-")
-	testDeepEqualErr(v6v1, v6v2, t, "-")
-
-	v7v1 := map[interface{}]uint32{"string-is-an-interface": 10}
-	bs7, _ := testMarshalErr(v7v1, h, t, "-")
-	v7v2 := make(map[interface{}]uint32)
-	testUnmarshalErr(v7v2, bs7, h, t, "-")
-	testDeepEqualErr(v7v1, v7v2, t, "-")
-	bs7, _ = testMarshalErr(&v7v1, h, t, "-")
-	v7v2 = nil
-	testUnmarshalErr(&v7v2, bs7, h, t, "-")
-	testDeepEqualErr(v7v1, v7v2, t, "-")
-
-	v8v1 := map[interface{}]uint64{"string-is-an-interface": 10}
-	bs8, _ := testMarshalErr(v8v1, h, t, "-")
-	v8v2 := make(map[interface{}]uint64)
-	testUnmarshalErr(v8v2, bs8, h, t, "-")
-	testDeepEqualErr(v8v1, v8v2, t, "-")
-	bs8, _ = testMarshalErr(&v8v1, h, t, "-")
-	v8v2 = nil
-	testUnmarshalErr(&v8v2, bs8, h, t, "-")
-	testDeepEqualErr(v8v1, v8v2, t, "-")
-
-	v9v1 := map[interface{}]uintptr{"string-is-an-interface": 10}
-	bs9, _ := testMarshalErr(v9v1, h, t, "-")
-	v9v2 := make(map[interface{}]uintptr)
-	testUnmarshalErr(v9v2, bs9, h, t, "-")
-	testDeepEqualErr(v9v1, v9v2, t, "-")
-	bs9, _ = testMarshalErr(&v9v1, h, t, "-")
-	v9v2 = nil
-	testUnmarshalErr(&v9v2, bs9, h, t, "-")
-	testDeepEqualErr(v9v1, v9v2, t, "-")
-
-	v10v1 := map[interface{}]int{"string-is-an-interface": 10}
-	bs10, _ := testMarshalErr(v10v1, h, t, "-")
-	v10v2 := make(map[interface{}]int)
-	testUnmarshalErr(v10v2, bs10, h, t, "-")
-	testDeepEqualErr(v10v1, v10v2, t, "-")
-	bs10, _ = testMarshalErr(&v10v1, h, t, "-")
-	v10v2 = nil
-	testUnmarshalErr(&v10v2, bs10, h, t, "-")
-	testDeepEqualErr(v10v1, v10v2, t, "-")
-
-	v11v1 := map[interface{}]int8{"string-is-an-interface": 10}
-	bs11, _ := testMarshalErr(v11v1, h, t, "-")
-	v11v2 := make(map[interface{}]int8)
-	testUnmarshalErr(v11v2, bs11, h, t, "-")
-	testDeepEqualErr(v11v1, v11v2, t, "-")
-	bs11, _ = testMarshalErr(&v11v1, h, t, "-")
-	v11v2 = nil
-	testUnmarshalErr(&v11v2, bs11, h, t, "-")
-	testDeepEqualErr(v11v1, v11v2, t, "-")
-
-	v12v1 := map[interface{}]int16{"string-is-an-interface": 10}
-	bs12, _ := testMarshalErr(v12v1, h, t, "-")
-	v12v2 := make(map[interface{}]int16)
-	testUnmarshalErr(v12v2, bs12, h, t, "-")
-	testDeepEqualErr(v12v1, v12v2, t, "-")
-	bs12, _ = testMarshalErr(&v12v1, h, t, "-")
-	v12v2 = nil
-	testUnmarshalErr(&v12v2, bs12, h, t, "-")
-	testDeepEqualErr(v12v1, v12v2, t, "-")
-
-	v13v1 := map[interface{}]int32{"string-is-an-interface": 10}
-	bs13, _ := testMarshalErr(v13v1, h, t, "-")
-	v13v2 := make(map[interface{}]int32)
-	testUnmarshalErr(v13v2, bs13, h, t, "-")
-	testDeepEqualErr(v13v1, v13v2, t, "-")
-	bs13, _ = testMarshalErr(&v13v1, h, t, "-")
-	v13v2 = nil
-	testUnmarshalErr(&v13v2, bs13, h, t, "-")
-	testDeepEqualErr(v13v1, v13v2, t, "-")
-
-	v14v1 := map[interface{}]int64{"string-is-an-interface": 10}
-	bs14, _ := testMarshalErr(v14v1, h, t, "-")
-	v14v2 := make(map[interface{}]int64)
-	testUnmarshalErr(v14v2, bs14, h, t, "-")
-	testDeepEqualErr(v14v1, v14v2, t, "-")
-	bs14, _ = testMarshalErr(&v14v1, h, t, "-")
-	v14v2 = nil
-	testUnmarshalErr(&v14v2, bs14, h, t, "-")
-	testDeepEqualErr(v14v1, v14v2, t, "-")
-
-	v15v1 := map[interface{}]float32{"string-is-an-interface": 10.1}
-	bs15, _ := testMarshalErr(v15v1, h, t, "-")
-	v15v2 := make(map[interface{}]float32)
-	testUnmarshalErr(v15v2, bs15, h, t, "-")
-	testDeepEqualErr(v15v1, v15v2, t, "-")
-	bs15, _ = testMarshalErr(&v15v1, h, t, "-")
-	v15v2 = nil
-	testUnmarshalErr(&v15v2, bs15, h, t, "-")
-	testDeepEqualErr(v15v1, v15v2, t, "-")
-
-	v16v1 := map[interface{}]float64{"string-is-an-interface": 10.1}
-	bs16, _ := testMarshalErr(v16v1, h, t, "-")
-	v16v2 := make(map[interface{}]float64)
-	testUnmarshalErr(v16v2, bs16, h, t, "-")
-	testDeepEqualErr(v16v1, v16v2, t, "-")
-	bs16, _ = testMarshalErr(&v16v1, h, t, "-")
-	v16v2 = nil
-	testUnmarshalErr(&v16v2, bs16, h, t, "-")
-	testDeepEqualErr(v16v1, v16v2, t, "-")
-
-	v17v1 := map[interface{}]bool{"string-is-an-interface": true}
-	bs17, _ := testMarshalErr(v17v1, h, t, "-")
-	v17v2 := make(map[interface{}]bool)
-	testUnmarshalErr(v17v2, bs17, h, t, "-")
-	testDeepEqualErr(v17v1, v17v2, t, "-")
-	bs17, _ = testMarshalErr(&v17v1, h, t, "-")
-	v17v2 = nil
-	testUnmarshalErr(&v17v2, bs17, h, t, "-")
-	testDeepEqualErr(v17v1, v17v2, t, "-")
-
-	v20v1 := map[string]interface{}{"some-string": "string-is-an-interface"}
-	bs20, _ := testMarshalErr(v20v1, h, t, "-")
-	v20v2 := make(map[string]interface{})
-	testUnmarshalErr(v20v2, bs20, h, t, "-")
-	testDeepEqualErr(v20v1, v20v2, t, "-")
-	bs20, _ = testMarshalErr(&v20v1, h, t, "-")
-	v20v2 = nil
-	testUnmarshalErr(&v20v2, bs20, h, t, "-")
-	testDeepEqualErr(v20v1, v20v2, t, "-")
-
-	v21v1 := map[string]string{"some-string": "some-string"}
-	bs21, _ := testMarshalErr(v21v1, h, t, "-")
-	v21v2 := make(map[string]string)
-	testUnmarshalErr(v21v2, bs21, h, t, "-")
-	testDeepEqualErr(v21v1, v21v2, t, "-")
-	bs21, _ = testMarshalErr(&v21v1, h, t, "-")
-	v21v2 = nil
-	testUnmarshalErr(&v21v2, bs21, h, t, "-")
-	testDeepEqualErr(v21v1, v21v2, t, "-")
-
-	v22v1 := map[string]uint{"some-string": 10}
-	bs22, _ := testMarshalErr(v22v1, h, t, "-")
-	v22v2 := make(map[string]uint)
-	testUnmarshalErr(v22v2, bs22, h, t, "-")
-	testDeepEqualErr(v22v1, v22v2, t, "-")
-	bs22, _ = testMarshalErr(&v22v1, h, t, "-")
-	v22v2 = nil
-	testUnmarshalErr(&v22v2, bs22, h, t, "-")
-	testDeepEqualErr(v22v1, v22v2, t, "-")
-
-	v23v1 := map[string]uint8{"some-string": 10}
-	bs23, _ := testMarshalErr(v23v1, h, t, "-")
-	v23v2 := make(map[string]uint8)
-	testUnmarshalErr(v23v2, bs23, h, t, "-")
-	testDeepEqualErr(v23v1, v23v2, t, "-")
-	bs23, _ = testMarshalErr(&v23v1, h, t, "-")
-	v23v2 = nil
-	testUnmarshalErr(&v23v2, bs23, h, t, "-")
-	testDeepEqualErr(v23v1, v23v2, t, "-")
-
-	v24v1 := map[string]uint16{"some-string": 10}
-	bs24, _ := testMarshalErr(v24v1, h, t, "-")
-	v24v2 := make(map[string]uint16)
-	testUnmarshalErr(v24v2, bs24, h, t, "-")
-	testDeepEqualErr(v24v1, v24v2, t, "-")
-	bs24, _ = testMarshalErr(&v24v1, h, t, "-")
-	v24v2 = nil
-	testUnmarshalErr(&v24v2, bs24, h, t, "-")
-	testDeepEqualErr(v24v1, v24v2, t, "-")
-
-	v25v1 := map[string]uint32{"some-string": 10}
-	bs25, _ := testMarshalErr(v25v1, h, t, "-")
-	v25v2 := make(map[string]uint32)
-	testUnmarshalErr(v25v2, bs25, h, t, "-")
-	testDeepEqualErr(v25v1, v25v2, t, "-")
-	bs25, _ = testMarshalErr(&v25v1, h, t, "-")
-	v25v2 = nil
-	testUnmarshalErr(&v25v2, bs25, h, t, "-")
-	testDeepEqualErr(v25v1, v25v2, t, "-")
-
-	v26v1 := map[string]uint64{"some-string": 10}
-	bs26, _ := testMarshalErr(v26v1, h, t, "-")
-	v26v2 := make(map[string]uint64)
-	testUnmarshalErr(v26v2, bs26, h, t, "-")
-	testDeepEqualErr(v26v1, v26v2, t, "-")
-	bs26, _ = testMarshalErr(&v26v1, h, t, "-")
-	v26v2 = nil
-	testUnmarshalErr(&v26v2, bs26, h, t, "-")
-	testDeepEqualErr(v26v1, v26v2, t, "-")
-
-	v27v1 := map[string]uintptr{"some-string": 10}
-	bs27, _ := testMarshalErr(v27v1, h, t, "-")
-	v27v2 := make(map[string]uintptr)
-	testUnmarshalErr(v27v2, bs27, h, t, "-")
-	testDeepEqualErr(v27v1, v27v2, t, "-")
-	bs27, _ = testMarshalErr(&v27v1, h, t, "-")
-	v27v2 = nil
-	testUnmarshalErr(&v27v2, bs27, h, t, "-")
-	testDeepEqualErr(v27v1, v27v2, t, "-")
-
-	v28v1 := map[string]int{"some-string": 10}
-	bs28, _ := testMarshalErr(v28v1, h, t, "-")
-	v28v2 := make(map[string]int)
-	testUnmarshalErr(v28v2, bs28, h, t, "-")
-	testDeepEqualErr(v28v1, v28v2, t, "-")
-	bs28, _ = testMarshalErr(&v28v1, h, t, "-")
-	v28v2 = nil
-	testUnmarshalErr(&v28v2, bs28, h, t, "-")
-	testDeepEqualErr(v28v1, v28v2, t, "-")
-
-	v29v1 := map[string]int8{"some-string": 10}
-	bs29, _ := testMarshalErr(v29v1, h, t, "-")
-	v29v2 := make(map[string]int8)
-	testUnmarshalErr(v29v2, bs29, h, t, "-")
-	testDeepEqualErr(v29v1, v29v2, t, "-")
-	bs29, _ = testMarshalErr(&v29v1, h, t, "-")
-	v29v2 = nil
-	testUnmarshalErr(&v29v2, bs29, h, t, "-")
-	testDeepEqualErr(v29v1, v29v2, t, "-")
-
-	v30v1 := map[string]int16{"some-string": 10}
-	bs30, _ := testMarshalErr(v30v1, h, t, "-")
-	v30v2 := make(map[string]int16)
-	testUnmarshalErr(v30v2, bs30, h, t, "-")
-	testDeepEqualErr(v30v1, v30v2, t, "-")
-	bs30, _ = testMarshalErr(&v30v1, h, t, "-")
-	v30v2 = nil
-	testUnmarshalErr(&v30v2, bs30, h, t, "-")
-	testDeepEqualErr(v30v1, v30v2, t, "-")
-
-	v31v1 := map[string]int32{"some-string": 10}
-	bs31, _ := testMarshalErr(v31v1, h, t, "-")
-	v31v2 := make(map[string]int32)
-	testUnmarshalErr(v31v2, bs31, h, t, "-")
-	testDeepEqualErr(v31v1, v31v2, t, "-")
-	bs31, _ = testMarshalErr(&v31v1, h, t, "-")
-	v31v2 = nil
-	testUnmarshalErr(&v31v2, bs31, h, t, "-")
-	testDeepEqualErr(v31v1, v31v2, t, "-")
-
-	v32v1 := map[string]int64{"some-string": 10}
-	bs32, _ := testMarshalErr(v32v1, h, t, "-")
-	v32v2 := make(map[string]int64)
-	testUnmarshalErr(v32v2, bs32, h, t, "-")
-	testDeepEqualErr(v32v1, v32v2, t, "-")
-	bs32, _ = testMarshalErr(&v32v1, h, t, "-")
-	v32v2 = nil
-	testUnmarshalErr(&v32v2, bs32, h, t, "-")
-	testDeepEqualErr(v32v1, v32v2, t, "-")
-
-	v33v1 := map[string]float32{"some-string": 10.1}
-	bs33, _ := testMarshalErr(v33v1, h, t, "-")
-	v33v2 := make(map[string]float32)
-	testUnmarshalErr(v33v2, bs33, h, t, "-")
-	testDeepEqualErr(v33v1, v33v2, t, "-")
-	bs33, _ = testMarshalErr(&v33v1, h, t, "-")
-	v33v2 = nil
-	testUnmarshalErr(&v33v2, bs33, h, t, "-")
-	testDeepEqualErr(v33v1, v33v2, t, "-")
-
-	v34v1 := map[string]float64{"some-string": 10.1}
-	bs34, _ := testMarshalErr(v34v1, h, t, "-")
-	v34v2 := make(map[string]float64)
-	testUnmarshalErr(v34v2, bs34, h, t, "-")
-	testDeepEqualErr(v34v1, v34v2, t, "-")
-	bs34, _ = testMarshalErr(&v34v1, h, t, "-")
-	v34v2 = nil
-	testUnmarshalErr(&v34v2, bs34, h, t, "-")
-	testDeepEqualErr(v34v1, v34v2, t, "-")
-
-	v35v1 := map[string]bool{"some-string": true}
-	bs35, _ := testMarshalErr(v35v1, h, t, "-")
-	v35v2 := make(map[string]bool)
-	testUnmarshalErr(v35v2, bs35, h, t, "-")
-	testDeepEqualErr(v35v1, v35v2, t, "-")
-	bs35, _ = testMarshalErr(&v35v1, h, t, "-")
-	v35v2 = nil
-	testUnmarshalErr(&v35v2, bs35, h, t, "-")
-	testDeepEqualErr(v35v1, v35v2, t, "-")
-
-	v38v1 := map[float32]interface{}{10.1: "string-is-an-interface"}
-	bs38, _ := testMarshalErr(v38v1, h, t, "-")
-	v38v2 := make(map[float32]interface{})
-	testUnmarshalErr(v38v2, bs38, h, t, "-")
-	testDeepEqualErr(v38v1, v38v2, t, "-")
-	bs38, _ = testMarshalErr(&v38v1, h, t, "-")
-	v38v2 = nil
-	testUnmarshalErr(&v38v2, bs38, h, t, "-")
-	testDeepEqualErr(v38v1, v38v2, t, "-")
-
-	v39v1 := map[float32]string{10.1: "some-string"}
-	bs39, _ := testMarshalErr(v39v1, h, t, "-")
-	v39v2 := make(map[float32]string)
-	testUnmarshalErr(v39v2, bs39, h, t, "-")
-	testDeepEqualErr(v39v1, v39v2, t, "-")
-	bs39, _ = testMarshalErr(&v39v1, h, t, "-")
-	v39v2 = nil
-	testUnmarshalErr(&v39v2, bs39, h, t, "-")
-	testDeepEqualErr(v39v1, v39v2, t, "-")
-
-	v40v1 := map[float32]uint{10.1: 10}
-	bs40, _ := testMarshalErr(v40v1, h, t, "-")
-	v40v2 := make(map[float32]uint)
-	testUnmarshalErr(v40v2, bs40, h, t, "-")
-	testDeepEqualErr(v40v1, v40v2, t, "-")
-	bs40, _ = testMarshalErr(&v40v1, h, t, "-")
-	v40v2 = nil
-	testUnmarshalErr(&v40v2, bs40, h, t, "-")
-	testDeepEqualErr(v40v1, v40v2, t, "-")
-
-	v41v1 := map[float32]uint8{10.1: 10}
-	bs41, _ := testMarshalErr(v41v1, h, t, "-")
-	v41v2 := make(map[float32]uint8)
-	testUnmarshalErr(v41v2, bs41, h, t, "-")
-	testDeepEqualErr(v41v1, v41v2, t, "-")
-	bs41, _ = testMarshalErr(&v41v1, h, t, "-")
-	v41v2 = nil
-	testUnmarshalErr(&v41v2, bs41, h, t, "-")
-	testDeepEqualErr(v41v1, v41v2, t, "-")
-
-	v42v1 := map[float32]uint16{10.1: 10}
-	bs42, _ := testMarshalErr(v42v1, h, t, "-")
-	v42v2 := make(map[float32]uint16)
-	testUnmarshalErr(v42v2, bs42, h, t, "-")
-	testDeepEqualErr(v42v1, v42v2, t, "-")
-	bs42, _ = testMarshalErr(&v42v1, h, t, "-")
-	v42v2 = nil
-	testUnmarshalErr(&v42v2, bs42, h, t, "-")
-	testDeepEqualErr(v42v1, v42v2, t, "-")
-
-	v43v1 := map[float32]uint32{10.1: 10}
-	bs43, _ := testMarshalErr(v43v1, h, t, "-")
-	v43v2 := make(map[float32]uint32)
-	testUnmarshalErr(v43v2, bs43, h, t, "-")
-	testDeepEqualErr(v43v1, v43v2, t, "-")
-	bs43, _ = testMarshalErr(&v43v1, h, t, "-")
-	v43v2 = nil
-	testUnmarshalErr(&v43v2, bs43, h, t, "-")
-	testDeepEqualErr(v43v1, v43v2, t, "-")
-
-	v44v1 := map[float32]uint64{10.1: 10}
-	bs44, _ := testMarshalErr(v44v1, h, t, "-")
-	v44v2 := make(map[float32]uint64)
-	testUnmarshalErr(v44v2, bs44, h, t, "-")
-	testDeepEqualErr(v44v1, v44v2, t, "-")
-	bs44, _ = testMarshalErr(&v44v1, h, t, "-")
-	v44v2 = nil
-	testUnmarshalErr(&v44v2, bs44, h, t, "-")
-	testDeepEqualErr(v44v1, v44v2, t, "-")
-
-	v45v1 := map[float32]uintptr{10.1: 10}
-	bs45, _ := testMarshalErr(v45v1, h, t, "-")
-	v45v2 := make(map[float32]uintptr)
-	testUnmarshalErr(v45v2, bs45, h, t, "-")
-	testDeepEqualErr(v45v1, v45v2, t, "-")
-	bs45, _ = testMarshalErr(&v45v1, h, t, "-")
-	v45v2 = nil
-	testUnmarshalErr(&v45v2, bs45, h, t, "-")
-	testDeepEqualErr(v45v1, v45v2, t, "-")
-
-	v46v1 := map[float32]int{10.1: 10}
-	bs46, _ := testMarshalErr(v46v1, h, t, "-")
-	v46v2 := make(map[float32]int)
-	testUnmarshalErr(v46v2, bs46, h, t, "-")
-	testDeepEqualErr(v46v1, v46v2, t, "-")
-	bs46, _ = testMarshalErr(&v46v1, h, t, "-")
-	v46v2 = nil
-	testUnmarshalErr(&v46v2, bs46, h, t, "-")
-	testDeepEqualErr(v46v1, v46v2, t, "-")
-
-	v47v1 := map[float32]int8{10.1: 10}
-	bs47, _ := testMarshalErr(v47v1, h, t, "-")
-	v47v2 := make(map[float32]int8)
-	testUnmarshalErr(v47v2, bs47, h, t, "-")
-	testDeepEqualErr(v47v1, v47v2, t, "-")
-	bs47, _ = testMarshalErr(&v47v1, h, t, "-")
-	v47v2 = nil
-	testUnmarshalErr(&v47v2, bs47, h, t, "-")
-	testDeepEqualErr(v47v1, v47v2, t, "-")
-
-	v48v1 := map[float32]int16{10.1: 10}
-	bs48, _ := testMarshalErr(v48v1, h, t, "-")
-	v48v2 := make(map[float32]int16)
-	testUnmarshalErr(v48v2, bs48, h, t, "-")
-	testDeepEqualErr(v48v1, v48v2, t, "-")
-	bs48, _ = testMarshalErr(&v48v1, h, t, "-")
-	v48v2 = nil
-	testUnmarshalErr(&v48v2, bs48, h, t, "-")
-	testDeepEqualErr(v48v1, v48v2, t, "-")
-
-	v49v1 := map[float32]int32{10.1: 10}
-	bs49, _ := testMarshalErr(v49v1, h, t, "-")
-	v49v2 := make(map[float32]int32)
-	testUnmarshalErr(v49v2, bs49, h, t, "-")
-	testDeepEqualErr(v49v1, v49v2, t, "-")
-	bs49, _ = testMarshalErr(&v49v1, h, t, "-")
-	v49v2 = nil
-	testUnmarshalErr(&v49v2, bs49, h, t, "-")
-	testDeepEqualErr(v49v1, v49v2, t, "-")
-
-	v50v1 := map[float32]int64{10.1: 10}
-	bs50, _ := testMarshalErr(v50v1, h, t, "-")
-	v50v2 := make(map[float32]int64)
-	testUnmarshalErr(v50v2, bs50, h, t, "-")
-	testDeepEqualErr(v50v1, v50v2, t, "-")
-	bs50, _ = testMarshalErr(&v50v1, h, t, "-")
-	v50v2 = nil
-	testUnmarshalErr(&v50v2, bs50, h, t, "-")
-	testDeepEqualErr(v50v1, v50v2, t, "-")
-
-	v51v1 := map[float32]float32{10.1: 10.1}
-	bs51, _ := testMarshalErr(v51v1, h, t, "-")
-	v51v2 := make(map[float32]float32)
-	testUnmarshalErr(v51v2, bs51, h, t, "-")
-	testDeepEqualErr(v51v1, v51v2, t, "-")
-	bs51, _ = testMarshalErr(&v51v1, h, t, "-")
-	v51v2 = nil
-	testUnmarshalErr(&v51v2, bs51, h, t, "-")
-	testDeepEqualErr(v51v1, v51v2, t, "-")
-
-	v52v1 := map[float32]float64{10.1: 10.1}
-	bs52, _ := testMarshalErr(v52v1, h, t, "-")
-	v52v2 := make(map[float32]float64)
-	testUnmarshalErr(v52v2, bs52, h, t, "-")
-	testDeepEqualErr(v52v1, v52v2, t, "-")
-	bs52, _ = testMarshalErr(&v52v1, h, t, "-")
-	v52v2 = nil
-	testUnmarshalErr(&v52v2, bs52, h, t, "-")
-	testDeepEqualErr(v52v1, v52v2, t, "-")
-
-	v53v1 := map[float32]bool{10.1: true}
-	bs53, _ := testMarshalErr(v53v1, h, t, "-")
-	v53v2 := make(map[float32]bool)
-	testUnmarshalErr(v53v2, bs53, h, t, "-")
-	testDeepEqualErr(v53v1, v53v2, t, "-")
-	bs53, _ = testMarshalErr(&v53v1, h, t, "-")
-	v53v2 = nil
-	testUnmarshalErr(&v53v2, bs53, h, t, "-")
-	testDeepEqualErr(v53v1, v53v2, t, "-")
-
-	v56v1 := map[float64]interface{}{10.1: "string-is-an-interface"}
-	bs56, _ := testMarshalErr(v56v1, h, t, "-")
-	v56v2 := make(map[float64]interface{})
-	testUnmarshalErr(v56v2, bs56, h, t, "-")
-	testDeepEqualErr(v56v1, v56v2, t, "-")
-	bs56, _ = testMarshalErr(&v56v1, h, t, "-")
-	v56v2 = nil
-	testUnmarshalErr(&v56v2, bs56, h, t, "-")
-	testDeepEqualErr(v56v1, v56v2, t, "-")
-
-	v57v1 := map[float64]string{10.1: "some-string"}
-	bs57, _ := testMarshalErr(v57v1, h, t, "-")
-	v57v2 := make(map[float64]string)
-	testUnmarshalErr(v57v2, bs57, h, t, "-")
-	testDeepEqualErr(v57v1, v57v2, t, "-")
-	bs57, _ = testMarshalErr(&v57v1, h, t, "-")
-	v57v2 = nil
-	testUnmarshalErr(&v57v2, bs57, h, t, "-")
-	testDeepEqualErr(v57v1, v57v2, t, "-")
-
-	v58v1 := map[float64]uint{10.1: 10}
-	bs58, _ := testMarshalErr(v58v1, h, t, "-")
-	v58v2 := make(map[float64]uint)
-	testUnmarshalErr(v58v2, bs58, h, t, "-")
-	testDeepEqualErr(v58v1, v58v2, t, "-")
-	bs58, _ = testMarshalErr(&v58v1, h, t, "-")
-	v58v2 = nil
-	testUnmarshalErr(&v58v2, bs58, h, t, "-")
-	testDeepEqualErr(v58v1, v58v2, t, "-")
-
-	v59v1 := map[float64]uint8{10.1: 10}
-	bs59, _ := testMarshalErr(v59v1, h, t, "-")
-	v59v2 := make(map[float64]uint8)
-	testUnmarshalErr(v59v2, bs59, h, t, "-")
-	testDeepEqualErr(v59v1, v59v2, t, "-")
-	bs59, _ = testMarshalErr(&v59v1, h, t, "-")
-	v59v2 = nil
-	testUnmarshalErr(&v59v2, bs59, h, t, "-")
-	testDeepEqualErr(v59v1, v59v2, t, "-")
-
-	v60v1 := map[float64]uint16{10.1: 10}
-	bs60, _ := testMarshalErr(v60v1, h, t, "-")
-	v60v2 := make(map[float64]uint16)
-	testUnmarshalErr(v60v2, bs60, h, t, "-")
-	testDeepEqualErr(v60v1, v60v2, t, "-")
-	bs60, _ = testMarshalErr(&v60v1, h, t, "-")
-	v60v2 = nil
-	testUnmarshalErr(&v60v2, bs60, h, t, "-")
-	testDeepEqualErr(v60v1, v60v2, t, "-")
-
-	v61v1 := map[float64]uint32{10.1: 10}
-	bs61, _ := testMarshalErr(v61v1, h, t, "-")
-	v61v2 := make(map[float64]uint32)
-	testUnmarshalErr(v61v2, bs61, h, t, "-")
-	testDeepEqualErr(v61v1, v61v2, t, "-")
-	bs61, _ = testMarshalErr(&v61v1, h, t, "-")
-	v61v2 = nil
-	testUnmarshalErr(&v61v2, bs61, h, t, "-")
-	testDeepEqualErr(v61v1, v61v2, t, "-")
-
-	v62v1 := map[float64]uint64{10.1: 10}
-	bs62, _ := testMarshalErr(v62v1, h, t, "-")
-	v62v2 := make(map[float64]uint64)
-	testUnmarshalErr(v62v2, bs62, h, t, "-")
-	testDeepEqualErr(v62v1, v62v2, t, "-")
-	bs62, _ = testMarshalErr(&v62v1, h, t, "-")
-	v62v2 = nil
-	testUnmarshalErr(&v62v2, bs62, h, t, "-")
-	testDeepEqualErr(v62v1, v62v2, t, "-")
-
-	v63v1 := map[float64]uintptr{10.1: 10}
-	bs63, _ := testMarshalErr(v63v1, h, t, "-")
-	v63v2 := make(map[float64]uintptr)
-	testUnmarshalErr(v63v2, bs63, h, t, "-")
-	testDeepEqualErr(v63v1, v63v2, t, "-")
-	bs63, _ = testMarshalErr(&v63v1, h, t, "-")
-	v63v2 = nil
-	testUnmarshalErr(&v63v2, bs63, h, t, "-")
-	testDeepEqualErr(v63v1, v63v2, t, "-")
-
-	v64v1 := map[float64]int{10.1: 10}
-	bs64, _ := testMarshalErr(v64v1, h, t, "-")
-	v64v2 := make(map[float64]int)
-	testUnmarshalErr(v64v2, bs64, h, t, "-")
-	testDeepEqualErr(v64v1, v64v2, t, "-")
-	bs64, _ = testMarshalErr(&v64v1, h, t, "-")
-	v64v2 = nil
-	testUnmarshalErr(&v64v2, bs64, h, t, "-")
-	testDeepEqualErr(v64v1, v64v2, t, "-")
-
-	v65v1 := map[float64]int8{10.1: 10}
-	bs65, _ := testMarshalErr(v65v1, h, t, "-")
-	v65v2 := make(map[float64]int8)
-	testUnmarshalErr(v65v2, bs65, h, t, "-")
-	testDeepEqualErr(v65v1, v65v2, t, "-")
-	bs65, _ = testMarshalErr(&v65v1, h, t, "-")
-	v65v2 = nil
-	testUnmarshalErr(&v65v2, bs65, h, t, "-")
-	testDeepEqualErr(v65v1, v65v2, t, "-")
-
-	v66v1 := map[float64]int16{10.1: 10}
-	bs66, _ := testMarshalErr(v66v1, h, t, "-")
-	v66v2 := make(map[float64]int16)
-	testUnmarshalErr(v66v2, bs66, h, t, "-")
-	testDeepEqualErr(v66v1, v66v2, t, "-")
-	bs66, _ = testMarshalErr(&v66v1, h, t, "-")
-	v66v2 = nil
-	testUnmarshalErr(&v66v2, bs66, h, t, "-")
-	testDeepEqualErr(v66v1, v66v2, t, "-")
-
-	v67v1 := map[float64]int32{10.1: 10}
-	bs67, _ := testMarshalErr(v67v1, h, t, "-")
-	v67v2 := make(map[float64]int32)
-	testUnmarshalErr(v67v2, bs67, h, t, "-")
-	testDeepEqualErr(v67v1, v67v2, t, "-")
-	bs67, _ = testMarshalErr(&v67v1, h, t, "-")
-	v67v2 = nil
-	testUnmarshalErr(&v67v2, bs67, h, t, "-")
-	testDeepEqualErr(v67v1, v67v2, t, "-")
-
-	v68v1 := map[float64]int64{10.1: 10}
-	bs68, _ := testMarshalErr(v68v1, h, t, "-")
-	v68v2 := make(map[float64]int64)
-	testUnmarshalErr(v68v2, bs68, h, t, "-")
-	testDeepEqualErr(v68v1, v68v2, t, "-")
-	bs68, _ = testMarshalErr(&v68v1, h, t, "-")
-	v68v2 = nil
-	testUnmarshalErr(&v68v2, bs68, h, t, "-")
-	testDeepEqualErr(v68v1, v68v2, t, "-")
-
-	v69v1 := map[float64]float32{10.1: 10.1}
-	bs69, _ := testMarshalErr(v69v1, h, t, "-")
-	v69v2 := make(map[float64]float32)
-	testUnmarshalErr(v69v2, bs69, h, t, "-")
-	testDeepEqualErr(v69v1, v69v2, t, "-")
-	bs69, _ = testMarshalErr(&v69v1, h, t, "-")
-	v69v2 = nil
-	testUnmarshalErr(&v69v2, bs69, h, t, "-")
-	testDeepEqualErr(v69v1, v69v2, t, "-")
-
-	v70v1 := map[float64]float64{10.1: 10.1}
-	bs70, _ := testMarshalErr(v70v1, h, t, "-")
-	v70v2 := make(map[float64]float64)
-	testUnmarshalErr(v70v2, bs70, h, t, "-")
-	testDeepEqualErr(v70v1, v70v2, t, "-")
-	bs70, _ = testMarshalErr(&v70v1, h, t, "-")
-	v70v2 = nil
-	testUnmarshalErr(&v70v2, bs70, h, t, "-")
-	testDeepEqualErr(v70v1, v70v2, t, "-")
-
-	v71v1 := map[float64]bool{10.1: true}
-	bs71, _ := testMarshalErr(v71v1, h, t, "-")
-	v71v2 := make(map[float64]bool)
-	testUnmarshalErr(v71v2, bs71, h, t, "-")
-	testDeepEqualErr(v71v1, v71v2, t, "-")
-	bs71, _ = testMarshalErr(&v71v1, h, t, "-")
-	v71v2 = nil
-	testUnmarshalErr(&v71v2, bs71, h, t, "-")
-	testDeepEqualErr(v71v1, v71v2, t, "-")
-
-	v74v1 := map[uint]interface{}{10: "string-is-an-interface"}
-	bs74, _ := testMarshalErr(v74v1, h, t, "-")
-	v74v2 := make(map[uint]interface{})
-	testUnmarshalErr(v74v2, bs74, h, t, "-")
-	testDeepEqualErr(v74v1, v74v2, t, "-")
-	bs74, _ = testMarshalErr(&v74v1, h, t, "-")
-	v74v2 = nil
-	testUnmarshalErr(&v74v2, bs74, h, t, "-")
-	testDeepEqualErr(v74v1, v74v2, t, "-")
-
-	v75v1 := map[uint]string{10: "some-string"}
-	bs75, _ := testMarshalErr(v75v1, h, t, "-")
-	v75v2 := make(map[uint]string)
-	testUnmarshalErr(v75v2, bs75, h, t, "-")
-	testDeepEqualErr(v75v1, v75v2, t, "-")
-	bs75, _ = testMarshalErr(&v75v1, h, t, "-")
-	v75v2 = nil
-	testUnmarshalErr(&v75v2, bs75, h, t, "-")
-	testDeepEqualErr(v75v1, v75v2, t, "-")
-
-	v76v1 := map[uint]uint{10: 10}
-	bs76, _ := testMarshalErr(v76v1, h, t, "-")
-	v76v2 := make(map[uint]uint)
-	testUnmarshalErr(v76v2, bs76, h, t, "-")
-	testDeepEqualErr(v76v1, v76v2, t, "-")
-	bs76, _ = testMarshalErr(&v76v1, h, t, "-")
-	v76v2 = nil
-	testUnmarshalErr(&v76v2, bs76, h, t, "-")
-	testDeepEqualErr(v76v1, v76v2, t, "-")
-
-	v77v1 := map[uint]uint8{10: 10}
-	bs77, _ := testMarshalErr(v77v1, h, t, "-")
-	v77v2 := make(map[uint]uint8)
-	testUnmarshalErr(v77v2, bs77, h, t, "-")
-	testDeepEqualErr(v77v1, v77v2, t, "-")
-	bs77, _ = testMarshalErr(&v77v1, h, t, "-")
-	v77v2 = nil
-	testUnmarshalErr(&v77v2, bs77, h, t, "-")
-	testDeepEqualErr(v77v1, v77v2, t, "-")
-
-	v78v1 := map[uint]uint16{10: 10}
-	bs78, _ := testMarshalErr(v78v1, h, t, "-")
-	v78v2 := make(map[uint]uint16)
-	testUnmarshalErr(v78v2, bs78, h, t, "-")
-	testDeepEqualErr(v78v1, v78v2, t, "-")
-	bs78, _ = testMarshalErr(&v78v1, h, t, "-")
-	v78v2 = nil
-	testUnmarshalErr(&v78v2, bs78, h, t, "-")
-	testDeepEqualErr(v78v1, v78v2, t, "-")
-
-	v79v1 := map[uint]uint32{10: 10}
-	bs79, _ := testMarshalErr(v79v1, h, t, "-")
-	v79v2 := make(map[uint]uint32)
-	testUnmarshalErr(v79v2, bs79, h, t, "-")
-	testDeepEqualErr(v79v1, v79v2, t, "-")
-	bs79, _ = testMarshalErr(&v79v1, h, t, "-")
-	v79v2 = nil
-	testUnmarshalErr(&v79v2, bs79, h, t, "-")
-	testDeepEqualErr(v79v1, v79v2, t, "-")
-
-	v80v1 := map[uint]uint64{10: 10}
-	bs80, _ := testMarshalErr(v80v1, h, t, "-")
-	v80v2 := make(map[uint]uint64)
-	testUnmarshalErr(v80v2, bs80, h, t, "-")
-	testDeepEqualErr(v80v1, v80v2, t, "-")
-	bs80, _ = testMarshalErr(&v80v1, h, t, "-")
-	v80v2 = nil
-	testUnmarshalErr(&v80v2, bs80, h, t, "-")
-	testDeepEqualErr(v80v1, v80v2, t, "-")
-
-	v81v1 := map[uint]uintptr{10: 10}
-	bs81, _ := testMarshalErr(v81v1, h, t, "-")
-	v81v2 := make(map[uint]uintptr)
-	testUnmarshalErr(v81v2, bs81, h, t, "-")
-	testDeepEqualErr(v81v1, v81v2, t, "-")
-	bs81, _ = testMarshalErr(&v81v1, h, t, "-")
-	v81v2 = nil
-	testUnmarshalErr(&v81v2, bs81, h, t, "-")
-	testDeepEqualErr(v81v1, v81v2, t, "-")
-
-	v82v1 := map[uint]int{10: 10}
-	bs82, _ := testMarshalErr(v82v1, h, t, "-")
-	v82v2 := make(map[uint]int)
-	testUnmarshalErr(v82v2, bs82, h, t, "-")
-	testDeepEqualErr(v82v1, v82v2, t, "-")
-	bs82, _ = testMarshalErr(&v82v1, h, t, "-")
-	v82v2 = nil
-	testUnmarshalErr(&v82v2, bs82, h, t, "-")
-	testDeepEqualErr(v82v1, v82v2, t, "-")
-
-	v83v1 := map[uint]int8{10: 10}
-	bs83, _ := testMarshalErr(v83v1, h, t, "-")
-	v83v2 := make(map[uint]int8)
-	testUnmarshalErr(v83v2, bs83, h, t, "-")
-	testDeepEqualErr(v83v1, v83v2, t, "-")
-	bs83, _ = testMarshalErr(&v83v1, h, t, "-")
-	v83v2 = nil
-	testUnmarshalErr(&v83v2, bs83, h, t, "-")
-	testDeepEqualErr(v83v1, v83v2, t, "-")
-
-	v84v1 := map[uint]int16{10: 10}
-	bs84, _ := testMarshalErr(v84v1, h, t, "-")
-	v84v2 := make(map[uint]int16)
-	testUnmarshalErr(v84v2, bs84, h, t, "-")
-	testDeepEqualErr(v84v1, v84v2, t, "-")
-	bs84, _ = testMarshalErr(&v84v1, h, t, "-")
-	v84v2 = nil
-	testUnmarshalErr(&v84v2, bs84, h, t, "-")
-	testDeepEqualErr(v84v1, v84v2, t, "-")
-
-	v85v1 := map[uint]int32{10: 10}
-	bs85, _ := testMarshalErr(v85v1, h, t, "-")
-	v85v2 := make(map[uint]int32)
-	testUnmarshalErr(v85v2, bs85, h, t, "-")
-	testDeepEqualErr(v85v1, v85v2, t, "-")
-	bs85, _ = testMarshalErr(&v85v1, h, t, "-")
-	v85v2 = nil
-	testUnmarshalErr(&v85v2, bs85, h, t, "-")
-	testDeepEqualErr(v85v1, v85v2, t, "-")
-
-	v86v1 := map[uint]int64{10: 10}
-	bs86, _ := testMarshalErr(v86v1, h, t, "-")
-	v86v2 := make(map[uint]int64)
-	testUnmarshalErr(v86v2, bs86, h, t, "-")
-	testDeepEqualErr(v86v1, v86v2, t, "-")
-	bs86, _ = testMarshalErr(&v86v1, h, t, "-")
-	v86v2 = nil
-	testUnmarshalErr(&v86v2, bs86, h, t, "-")
-	testDeepEqualErr(v86v1, v86v2, t, "-")
-
-	v87v1 := map[uint]float32{10: 10.1}
-	bs87, _ := testMarshalErr(v87v1, h, t, "-")
-	v87v2 := make(map[uint]float32)
-	testUnmarshalErr(v87v2, bs87, h, t, "-")
-	testDeepEqualErr(v87v1, v87v2, t, "-")
-	bs87, _ = testMarshalErr(&v87v1, h, t, "-")
-	v87v2 = nil
-	testUnmarshalErr(&v87v2, bs87, h, t, "-")
-	testDeepEqualErr(v87v1, v87v2, t, "-")
-
-	v88v1 := map[uint]float64{10: 10.1}
-	bs88, _ := testMarshalErr(v88v1, h, t, "-")
-	v88v2 := make(map[uint]float64)
-	testUnmarshalErr(v88v2, bs88, h, t, "-")
-	testDeepEqualErr(v88v1, v88v2, t, "-")
-	bs88, _ = testMarshalErr(&v88v1, h, t, "-")
-	v88v2 = nil
-	testUnmarshalErr(&v88v2, bs88, h, t, "-")
-	testDeepEqualErr(v88v1, v88v2, t, "-")
-
-	v89v1 := map[uint]bool{10: true}
-	bs89, _ := testMarshalErr(v89v1, h, t, "-")
-	v89v2 := make(map[uint]bool)
-	testUnmarshalErr(v89v2, bs89, h, t, "-")
-	testDeepEqualErr(v89v1, v89v2, t, "-")
-	bs89, _ = testMarshalErr(&v89v1, h, t, "-")
-	v89v2 = nil
-	testUnmarshalErr(&v89v2, bs89, h, t, "-")
-	testDeepEqualErr(v89v1, v89v2, t, "-")
-
-	v91v1 := map[uint8]interface{}{10: "string-is-an-interface"}
-	bs91, _ := testMarshalErr(v91v1, h, t, "-")
-	v91v2 := make(map[uint8]interface{})
-	testUnmarshalErr(v91v2, bs91, h, t, "-")
-	testDeepEqualErr(v91v1, v91v2, t, "-")
-	bs91, _ = testMarshalErr(&v91v1, h, t, "-")
-	v91v2 = nil
-	testUnmarshalErr(&v91v2, bs91, h, t, "-")
-	testDeepEqualErr(v91v1, v91v2, t, "-")
-
-	v92v1 := map[uint8]string{10: "some-string"}
-	bs92, _ := testMarshalErr(v92v1, h, t, "-")
-	v92v2 := make(map[uint8]string)
-	testUnmarshalErr(v92v2, bs92, h, t, "-")
-	testDeepEqualErr(v92v1, v92v2, t, "-")
-	bs92, _ = testMarshalErr(&v92v1, h, t, "-")
-	v92v2 = nil
-	testUnmarshalErr(&v92v2, bs92, h, t, "-")
-	testDeepEqualErr(v92v1, v92v2, t, "-")
-
-	v93v1 := map[uint8]uint{10: 10}
-	bs93, _ := testMarshalErr(v93v1, h, t, "-")
-	v93v2 := make(map[uint8]uint)
-	testUnmarshalErr(v93v2, bs93, h, t, "-")
-	testDeepEqualErr(v93v1, v93v2, t, "-")
-	bs93, _ = testMarshalErr(&v93v1, h, t, "-")
-	v93v2 = nil
-	testUnmarshalErr(&v93v2, bs93, h, t, "-")
-	testDeepEqualErr(v93v1, v93v2, t, "-")
-
-	v94v1 := map[uint8]uint8{10: 10}
-	bs94, _ := testMarshalErr(v94v1, h, t, "-")
-	v94v2 := make(map[uint8]uint8)
-	testUnmarshalErr(v94v2, bs94, h, t, "-")
-	testDeepEqualErr(v94v1, v94v2, t, "-")
-	bs94, _ = testMarshalErr(&v94v1, h, t, "-")
-	v94v2 = nil
-	testUnmarshalErr(&v94v2, bs94, h, t, "-")
-	testDeepEqualErr(v94v1, v94v2, t, "-")
-
-	v95v1 := map[uint8]uint16{10: 10}
-	bs95, _ := testMarshalErr(v95v1, h, t, "-")
-	v95v2 := make(map[uint8]uint16)
-	testUnmarshalErr(v95v2, bs95, h, t, "-")
-	testDeepEqualErr(v95v1, v95v2, t, "-")
-	bs95, _ = testMarshalErr(&v95v1, h, t, "-")
-	v95v2 = nil
-	testUnmarshalErr(&v95v2, bs95, h, t, "-")
-	testDeepEqualErr(v95v1, v95v2, t, "-")
-
-	v96v1 := map[uint8]uint32{10: 10}
-	bs96, _ := testMarshalErr(v96v1, h, t, "-")
-	v96v2 := make(map[uint8]uint32)
-	testUnmarshalErr(v96v2, bs96, h, t, "-")
-	testDeepEqualErr(v96v1, v96v2, t, "-")
-	bs96, _ = testMarshalErr(&v96v1, h, t, "-")
-	v96v2 = nil
-	testUnmarshalErr(&v96v2, bs96, h, t, "-")
-	testDeepEqualErr(v96v1, v96v2, t, "-")
-
-	v97v1 := map[uint8]uint64{10: 10}
-	bs97, _ := testMarshalErr(v97v1, h, t, "-")
-	v97v2 := make(map[uint8]uint64)
-	testUnmarshalErr(v97v2, bs97, h, t, "-")
-	testDeepEqualErr(v97v1, v97v2, t, "-")
-	bs97, _ = testMarshalErr(&v97v1, h, t, "-")
-	v97v2 = nil
-	testUnmarshalErr(&v97v2, bs97, h, t, "-")
-	testDeepEqualErr(v97v1, v97v2, t, "-")
-
-	v98v1 := map[uint8]uintptr{10: 10}
-	bs98, _ := testMarshalErr(v98v1, h, t, "-")
-	v98v2 := make(map[uint8]uintptr)
-	testUnmarshalErr(v98v2, bs98, h, t, "-")
-	testDeepEqualErr(v98v1, v98v2, t, "-")
-	bs98, _ = testMarshalErr(&v98v1, h, t, "-")
-	v98v2 = nil
-	testUnmarshalErr(&v98v2, bs98, h, t, "-")
-	testDeepEqualErr(v98v1, v98v2, t, "-")
-
-	v99v1 := map[uint8]int{10: 10}
-	bs99, _ := testMarshalErr(v99v1, h, t, "-")
-	v99v2 := make(map[uint8]int)
-	testUnmarshalErr(v99v2, bs99, h, t, "-")
-	testDeepEqualErr(v99v1, v99v2, t, "-")
-	bs99, _ = testMarshalErr(&v99v1, h, t, "-")
-	v99v2 = nil
-	testUnmarshalErr(&v99v2, bs99, h, t, "-")
-	testDeepEqualErr(v99v1, v99v2, t, "-")
-
-	v100v1 := map[uint8]int8{10: 10}
-	bs100, _ := testMarshalErr(v100v1, h, t, "-")
-	v100v2 := make(map[uint8]int8)
-	testUnmarshalErr(v100v2, bs100, h, t, "-")
-	testDeepEqualErr(v100v1, v100v2, t, "-")
-	bs100, _ = testMarshalErr(&v100v1, h, t, "-")
-	v100v2 = nil
-	testUnmarshalErr(&v100v2, bs100, h, t, "-")
-	testDeepEqualErr(v100v1, v100v2, t, "-")
-
-	v101v1 := map[uint8]int16{10: 10}
-	bs101, _ := testMarshalErr(v101v1, h, t, "-")
-	v101v2 := make(map[uint8]int16)
-	testUnmarshalErr(v101v2, bs101, h, t, "-")
-	testDeepEqualErr(v101v1, v101v2, t, "-")
-	bs101, _ = testMarshalErr(&v101v1, h, t, "-")
-	v101v2 = nil
-	testUnmarshalErr(&v101v2, bs101, h, t, "-")
-	testDeepEqualErr(v101v1, v101v2, t, "-")
-
-	v102v1 := map[uint8]int32{10: 10}
-	bs102, _ := testMarshalErr(v102v1, h, t, "-")
-	v102v2 := make(map[uint8]int32)
-	testUnmarshalErr(v102v2, bs102, h, t, "-")
-	testDeepEqualErr(v102v1, v102v2, t, "-")
-	bs102, _ = testMarshalErr(&v102v1, h, t, "-")
-	v102v2 = nil
-	testUnmarshalErr(&v102v2, bs102, h, t, "-")
-	testDeepEqualErr(v102v1, v102v2, t, "-")
-
-	v103v1 := map[uint8]int64{10: 10}
-	bs103, _ := testMarshalErr(v103v1, h, t, "-")
-	v103v2 := make(map[uint8]int64)
-	testUnmarshalErr(v103v2, bs103, h, t, "-")
-	testDeepEqualErr(v103v1, v103v2, t, "-")
-	bs103, _ = testMarshalErr(&v103v1, h, t, "-")
-	v103v2 = nil
-	testUnmarshalErr(&v103v2, bs103, h, t, "-")
-	testDeepEqualErr(v103v1, v103v2, t, "-")
-
-	v104v1 := map[uint8]float32{10: 10.1}
-	bs104, _ := testMarshalErr(v104v1, h, t, "-")
-	v104v2 := make(map[uint8]float32)
-	testUnmarshalErr(v104v2, bs104, h, t, "-")
-	testDeepEqualErr(v104v1, v104v2, t, "-")
-	bs104, _ = testMarshalErr(&v104v1, h, t, "-")
-	v104v2 = nil
-	testUnmarshalErr(&v104v2, bs104, h, t, "-")
-	testDeepEqualErr(v104v1, v104v2, t, "-")
-
-	v105v1 := map[uint8]float64{10: 10.1}
-	bs105, _ := testMarshalErr(v105v1, h, t, "-")
-	v105v2 := make(map[uint8]float64)
-	testUnmarshalErr(v105v2, bs105, h, t, "-")
-	testDeepEqualErr(v105v1, v105v2, t, "-")
-	bs105, _ = testMarshalErr(&v105v1, h, t, "-")
-	v105v2 = nil
-	testUnmarshalErr(&v105v2, bs105, h, t, "-")
-	testDeepEqualErr(v105v1, v105v2, t, "-")
-
-	v106v1 := map[uint8]bool{10: true}
-	bs106, _ := testMarshalErr(v106v1, h, t, "-")
-	v106v2 := make(map[uint8]bool)
-	testUnmarshalErr(v106v2, bs106, h, t, "-")
-	testDeepEqualErr(v106v1, v106v2, t, "-")
-	bs106, _ = testMarshalErr(&v106v1, h, t, "-")
-	v106v2 = nil
-	testUnmarshalErr(&v106v2, bs106, h, t, "-")
-	testDeepEqualErr(v106v1, v106v2, t, "-")
-
-	v109v1 := map[uint16]interface{}{10: "string-is-an-interface"}
-	bs109, _ := testMarshalErr(v109v1, h, t, "-")
-	v109v2 := make(map[uint16]interface{})
-	testUnmarshalErr(v109v2, bs109, h, t, "-")
-	testDeepEqualErr(v109v1, v109v2, t, "-")
-	bs109, _ = testMarshalErr(&v109v1, h, t, "-")
-	v109v2 = nil
-	testUnmarshalErr(&v109v2, bs109, h, t, "-")
-	testDeepEqualErr(v109v1, v109v2, t, "-")
-
-	v110v1 := map[uint16]string{10: "some-string"}
-	bs110, _ := testMarshalErr(v110v1, h, t, "-")
-	v110v2 := make(map[uint16]string)
-	testUnmarshalErr(v110v2, bs110, h, t, "-")
-	testDeepEqualErr(v110v1, v110v2, t, "-")
-	bs110, _ = testMarshalErr(&v110v1, h, t, "-")
-	v110v2 = nil
-	testUnmarshalErr(&v110v2, bs110, h, t, "-")
-	testDeepEqualErr(v110v1, v110v2, t, "-")
-
-	v111v1 := map[uint16]uint{10: 10}
-	bs111, _ := testMarshalErr(v111v1, h, t, "-")
-	v111v2 := make(map[uint16]uint)
-	testUnmarshalErr(v111v2, bs111, h, t, "-")
-	testDeepEqualErr(v111v1, v111v2, t, "-")
-	bs111, _ = testMarshalErr(&v111v1, h, t, "-")
-	v111v2 = nil
-	testUnmarshalErr(&v111v2, bs111, h, t, "-")
-	testDeepEqualErr(v111v1, v111v2, t, "-")
-
-	v112v1 := map[uint16]uint8{10: 10}
-	bs112, _ := testMarshalErr(v112v1, h, t, "-")
-	v112v2 := make(map[uint16]uint8)
-	testUnmarshalErr(v112v2, bs112, h, t, "-")
-	testDeepEqualErr(v112v1, v112v2, t, "-")
-	bs112, _ = testMarshalErr(&v112v1, h, t, "-")
-	v112v2 = nil
-	testUnmarshalErr(&v112v2, bs112, h, t, "-")
-	testDeepEqualErr(v112v1, v112v2, t, "-")
-
-	v113v1 := map[uint16]uint16{10: 10}
-	bs113, _ := testMarshalErr(v113v1, h, t, "-")
-	v113v2 := make(map[uint16]uint16)
-	testUnmarshalErr(v113v2, bs113, h, t, "-")
-	testDeepEqualErr(v113v1, v113v2, t, "-")
-	bs113, _ = testMarshalErr(&v113v1, h, t, "-")
-	v113v2 = nil
-	testUnmarshalErr(&v113v2, bs113, h, t, "-")
-	testDeepEqualErr(v113v1, v113v2, t, "-")
-
-	v114v1 := map[uint16]uint32{10: 10}
-	bs114, _ := testMarshalErr(v114v1, h, t, "-")
-	v114v2 := make(map[uint16]uint32)
-	testUnmarshalErr(v114v2, bs114, h, t, "-")
-	testDeepEqualErr(v114v1, v114v2, t, "-")
-	bs114, _ = testMarshalErr(&v114v1, h, t, "-")
-	v114v2 = nil
-	testUnmarshalErr(&v114v2, bs114, h, t, "-")
-	testDeepEqualErr(v114v1, v114v2, t, "-")
-
-	v115v1 := map[uint16]uint64{10: 10}
-	bs115, _ := testMarshalErr(v115v1, h, t, "-")
-	v115v2 := make(map[uint16]uint64)
-	testUnmarshalErr(v115v2, bs115, h, t, "-")
-	testDeepEqualErr(v115v1, v115v2, t, "-")
-	bs115, _ = testMarshalErr(&v115v1, h, t, "-")
-	v115v2 = nil
-	testUnmarshalErr(&v115v2, bs115, h, t, "-")
-	testDeepEqualErr(v115v1, v115v2, t, "-")
-
-	v116v1 := map[uint16]uintptr{10: 10}
-	bs116, _ := testMarshalErr(v116v1, h, t, "-")
-	v116v2 := make(map[uint16]uintptr)
-	testUnmarshalErr(v116v2, bs116, h, t, "-")
-	testDeepEqualErr(v116v1, v116v2, t, "-")
-	bs116, _ = testMarshalErr(&v116v1, h, t, "-")
-	v116v2 = nil
-	testUnmarshalErr(&v116v2, bs116, h, t, "-")
-	testDeepEqualErr(v116v1, v116v2, t, "-")
-
-	v117v1 := map[uint16]int{10: 10}
-	bs117, _ := testMarshalErr(v117v1, h, t, "-")
-	v117v2 := make(map[uint16]int)
-	testUnmarshalErr(v117v2, bs117, h, t, "-")
-	testDeepEqualErr(v117v1, v117v2, t, "-")
-	bs117, _ = testMarshalErr(&v117v1, h, t, "-")
-	v117v2 = nil
-	testUnmarshalErr(&v117v2, bs117, h, t, "-")
-	testDeepEqualErr(v117v1, v117v2, t, "-")
-
-	v118v1 := map[uint16]int8{10: 10}
-	bs118, _ := testMarshalErr(v118v1, h, t, "-")
-	v118v2 := make(map[uint16]int8)
-	testUnmarshalErr(v118v2, bs118, h, t, "-")
-	testDeepEqualErr(v118v1, v118v2, t, "-")
-	bs118, _ = testMarshalErr(&v118v1, h, t, "-")
-	v118v2 = nil
-	testUnmarshalErr(&v118v2, bs118, h, t, "-")
-	testDeepEqualErr(v118v1, v118v2, t, "-")
-
-	v119v1 := map[uint16]int16{10: 10}
-	bs119, _ := testMarshalErr(v119v1, h, t, "-")
-	v119v2 := make(map[uint16]int16)
-	testUnmarshalErr(v119v2, bs119, h, t, "-")
-	testDeepEqualErr(v119v1, v119v2, t, "-")
-	bs119, _ = testMarshalErr(&v119v1, h, t, "-")
-	v119v2 = nil
-	testUnmarshalErr(&v119v2, bs119, h, t, "-")
-	testDeepEqualErr(v119v1, v119v2, t, "-")
-
-	v120v1 := map[uint16]int32{10: 10}
-	bs120, _ := testMarshalErr(v120v1, h, t, "-")
-	v120v2 := make(map[uint16]int32)
-	testUnmarshalErr(v120v2, bs120, h, t, "-")
-	testDeepEqualErr(v120v1, v120v2, t, "-")
-	bs120, _ = testMarshalErr(&v120v1, h, t, "-")
-	v120v2 = nil
-	testUnmarshalErr(&v120v2, bs120, h, t, "-")
-	testDeepEqualErr(v120v1, v120v2, t, "-")
-
-	v121v1 := map[uint16]int64{10: 10}
-	bs121, _ := testMarshalErr(v121v1, h, t, "-")
-	v121v2 := make(map[uint16]int64)
-	testUnmarshalErr(v121v2, bs121, h, t, "-")
-	testDeepEqualErr(v121v1, v121v2, t, "-")
-	bs121, _ = testMarshalErr(&v121v1, h, t, "-")
-	v121v2 = nil
-	testUnmarshalErr(&v121v2, bs121, h, t, "-")
-	testDeepEqualErr(v121v1, v121v2, t, "-")
-
-	v122v1 := map[uint16]float32{10: 10.1}
-	bs122, _ := testMarshalErr(v122v1, h, t, "-")
-	v122v2 := make(map[uint16]float32)
-	testUnmarshalErr(v122v2, bs122, h, t, "-")
-	testDeepEqualErr(v122v1, v122v2, t, "-")
-	bs122, _ = testMarshalErr(&v122v1, h, t, "-")
-	v122v2 = nil
-	testUnmarshalErr(&v122v2, bs122, h, t, "-")
-	testDeepEqualErr(v122v1, v122v2, t, "-")
-
-	v123v1 := map[uint16]float64{10: 10.1}
-	bs123, _ := testMarshalErr(v123v1, h, t, "-")
-	v123v2 := make(map[uint16]float64)
-	testUnmarshalErr(v123v2, bs123, h, t, "-")
-	testDeepEqualErr(v123v1, v123v2, t, "-")
-	bs123, _ = testMarshalErr(&v123v1, h, t, "-")
-	v123v2 = nil
-	testUnmarshalErr(&v123v2, bs123, h, t, "-")
-	testDeepEqualErr(v123v1, v123v2, t, "-")
-
-	v124v1 := map[uint16]bool{10: true}
-	bs124, _ := testMarshalErr(v124v1, h, t, "-")
-	v124v2 := make(map[uint16]bool)
-	testUnmarshalErr(v124v2, bs124, h, t, "-")
-	testDeepEqualErr(v124v1, v124v2, t, "-")
-	bs124, _ = testMarshalErr(&v124v1, h, t, "-")
-	v124v2 = nil
-	testUnmarshalErr(&v124v2, bs124, h, t, "-")
-	testDeepEqualErr(v124v1, v124v2, t, "-")
-
-	v127v1 := map[uint32]interface{}{10: "string-is-an-interface"}
-	bs127, _ := testMarshalErr(v127v1, h, t, "-")
-	v127v2 := make(map[uint32]interface{})
-	testUnmarshalErr(v127v2, bs127, h, t, "-")
-	testDeepEqualErr(v127v1, v127v2, t, "-")
-	bs127, _ = testMarshalErr(&v127v1, h, t, "-")
-	v127v2 = nil
-	testUnmarshalErr(&v127v2, bs127, h, t, "-")
-	testDeepEqualErr(v127v1, v127v2, t, "-")
-
-	v128v1 := map[uint32]string{10: "some-string"}
-	bs128, _ := testMarshalErr(v128v1, h, t, "-")
-	v128v2 := make(map[uint32]string)
-	testUnmarshalErr(v128v2, bs128, h, t, "-")
-	testDeepEqualErr(v128v1, v128v2, t, "-")
-	bs128, _ = testMarshalErr(&v128v1, h, t, "-")
-	v128v2 = nil
-	testUnmarshalErr(&v128v2, bs128, h, t, "-")
-	testDeepEqualErr(v128v1, v128v2, t, "-")
-
-	v129v1 := map[uint32]uint{10: 10}
-	bs129, _ := testMarshalErr(v129v1, h, t, "-")
-	v129v2 := make(map[uint32]uint)
-	testUnmarshalErr(v129v2, bs129, h, t, "-")
-	testDeepEqualErr(v129v1, v129v2, t, "-")
-	bs129, _ = testMarshalErr(&v129v1, h, t, "-")
-	v129v2 = nil
-	testUnmarshalErr(&v129v2, bs129, h, t, "-")
-	testDeepEqualErr(v129v1, v129v2, t, "-")
-
-	v130v1 := map[uint32]uint8{10: 10}
-	bs130, _ := testMarshalErr(v130v1, h, t, "-")
-	v130v2 := make(map[uint32]uint8)
-	testUnmarshalErr(v130v2, bs130, h, t, "-")
-	testDeepEqualErr(v130v1, v130v2, t, "-")
-	bs130, _ = testMarshalErr(&v130v1, h, t, "-")
-	v130v2 = nil
-	testUnmarshalErr(&v130v2, bs130, h, t, "-")
-	testDeepEqualErr(v130v1, v130v2, t, "-")
-
-	v131v1 := map[uint32]uint16{10: 10}
-	bs131, _ := testMarshalErr(v131v1, h, t, "-")
-	v131v2 := make(map[uint32]uint16)
-	testUnmarshalErr(v131v2, bs131, h, t, "-")
-	testDeepEqualErr(v131v1, v131v2, t, "-")
-	bs131, _ = testMarshalErr(&v131v1, h, t, "-")
-	v131v2 = nil
-	testUnmarshalErr(&v131v2, bs131, h, t, "-")
-	testDeepEqualErr(v131v1, v131v2, t, "-")
-
-	v132v1 := map[uint32]uint32{10: 10}
-	bs132, _ := testMarshalErr(v132v1, h, t, "-")
-	v132v2 := make(map[uint32]uint32)
-	testUnmarshalErr(v132v2, bs132, h, t, "-")
-	testDeepEqualErr(v132v1, v132v2, t, "-")
-	bs132, _ = testMarshalErr(&v132v1, h, t, "-")
-	v132v2 = nil
-	testUnmarshalErr(&v132v2, bs132, h, t, "-")
-	testDeepEqualErr(v132v1, v132v2, t, "-")
-
-	v133v1 := map[uint32]uint64{10: 10}
-	bs133, _ := testMarshalErr(v133v1, h, t, "-")
-	v133v2 := make(map[uint32]uint64)
-	testUnmarshalErr(v133v2, bs133, h, t, "-")
-	testDeepEqualErr(v133v1, v133v2, t, "-")
-	bs133, _ = testMarshalErr(&v133v1, h, t, "-")
-	v133v2 = nil
-	testUnmarshalErr(&v133v2, bs133, h, t, "-")
-	testDeepEqualErr(v133v1, v133v2, t, "-")
-
-	v134v1 := map[uint32]uintptr{10: 10}
-	bs134, _ := testMarshalErr(v134v1, h, t, "-")
-	v134v2 := make(map[uint32]uintptr)
-	testUnmarshalErr(v134v2, bs134, h, t, "-")
-	testDeepEqualErr(v134v1, v134v2, t, "-")
-	bs134, _ = testMarshalErr(&v134v1, h, t, "-")
-	v134v2 = nil
-	testUnmarshalErr(&v134v2, bs134, h, t, "-")
-	testDeepEqualErr(v134v1, v134v2, t, "-")
-
-	v135v1 := map[uint32]int{10: 10}
-	bs135, _ := testMarshalErr(v135v1, h, t, "-")
-	v135v2 := make(map[uint32]int)
-	testUnmarshalErr(v135v2, bs135, h, t, "-")
-	testDeepEqualErr(v135v1, v135v2, t, "-")
-	bs135, _ = testMarshalErr(&v135v1, h, t, "-")
-	v135v2 = nil
-	testUnmarshalErr(&v135v2, bs135, h, t, "-")
-	testDeepEqualErr(v135v1, v135v2, t, "-")
-
-	v136v1 := map[uint32]int8{10: 10}
-	bs136, _ := testMarshalErr(v136v1, h, t, "-")
-	v136v2 := make(map[uint32]int8)
-	testUnmarshalErr(v136v2, bs136, h, t, "-")
-	testDeepEqualErr(v136v1, v136v2, t, "-")
-	bs136, _ = testMarshalErr(&v136v1, h, t, "-")
-	v136v2 = nil
-	testUnmarshalErr(&v136v2, bs136, h, t, "-")
-	testDeepEqualErr(v136v1, v136v2, t, "-")
-
-	v137v1 := map[uint32]int16{10: 10}
-	bs137, _ := testMarshalErr(v137v1, h, t, "-")
-	v137v2 := make(map[uint32]int16)
-	testUnmarshalErr(v137v2, bs137, h, t, "-")
-	testDeepEqualErr(v137v1, v137v2, t, "-")
-	bs137, _ = testMarshalErr(&v137v1, h, t, "-")
-	v137v2 = nil
-	testUnmarshalErr(&v137v2, bs137, h, t, "-")
-	testDeepEqualErr(v137v1, v137v2, t, "-")
-
-	v138v1 := map[uint32]int32{10: 10}
-	bs138, _ := testMarshalErr(v138v1, h, t, "-")
-	v138v2 := make(map[uint32]int32)
-	testUnmarshalErr(v138v2, bs138, h, t, "-")
-	testDeepEqualErr(v138v1, v138v2, t, "-")
-	bs138, _ = testMarshalErr(&v138v1, h, t, "-")
-	v138v2 = nil
-	testUnmarshalErr(&v138v2, bs138, h, t, "-")
-	testDeepEqualErr(v138v1, v138v2, t, "-")
-
-	v139v1 := map[uint32]int64{10: 10}
-	bs139, _ := testMarshalErr(v139v1, h, t, "-")
-	v139v2 := make(map[uint32]int64)
-	testUnmarshalErr(v139v2, bs139, h, t, "-")
-	testDeepEqualErr(v139v1, v139v2, t, "-")
-	bs139, _ = testMarshalErr(&v139v1, h, t, "-")
-	v139v2 = nil
-	testUnmarshalErr(&v139v2, bs139, h, t, "-")
-	testDeepEqualErr(v139v1, v139v2, t, "-")
-
-	v140v1 := map[uint32]float32{10: 10.1}
-	bs140, _ := testMarshalErr(v140v1, h, t, "-")
-	v140v2 := make(map[uint32]float32)
-	testUnmarshalErr(v140v2, bs140, h, t, "-")
-	testDeepEqualErr(v140v1, v140v2, t, "-")
-	bs140, _ = testMarshalErr(&v140v1, h, t, "-")
-	v140v2 = nil
-	testUnmarshalErr(&v140v2, bs140, h, t, "-")
-	testDeepEqualErr(v140v1, v140v2, t, "-")
-
-	v141v1 := map[uint32]float64{10: 10.1}
-	bs141, _ := testMarshalErr(v141v1, h, t, "-")
-	v141v2 := make(map[uint32]float64)
-	testUnmarshalErr(v141v2, bs141, h, t, "-")
-	testDeepEqualErr(v141v1, v141v2, t, "-")
-	bs141, _ = testMarshalErr(&v141v1, h, t, "-")
-	v141v2 = nil
-	testUnmarshalErr(&v141v2, bs141, h, t, "-")
-	testDeepEqualErr(v141v1, v141v2, t, "-")
-
-	v142v1 := map[uint32]bool{10: true}
-	bs142, _ := testMarshalErr(v142v1, h, t, "-")
-	v142v2 := make(map[uint32]bool)
-	testUnmarshalErr(v142v2, bs142, h, t, "-")
-	testDeepEqualErr(v142v1, v142v2, t, "-")
-	bs142, _ = testMarshalErr(&v142v1, h, t, "-")
-	v142v2 = nil
-	testUnmarshalErr(&v142v2, bs142, h, t, "-")
-	testDeepEqualErr(v142v1, v142v2, t, "-")
-
-	v145v1 := map[uint64]interface{}{10: "string-is-an-interface"}
-	bs145, _ := testMarshalErr(v145v1, h, t, "-")
-	v145v2 := make(map[uint64]interface{})
-	testUnmarshalErr(v145v2, bs145, h, t, "-")
-	testDeepEqualErr(v145v1, v145v2, t, "-")
-	bs145, _ = testMarshalErr(&v145v1, h, t, "-")
-	v145v2 = nil
-	testUnmarshalErr(&v145v2, bs145, h, t, "-")
-	testDeepEqualErr(v145v1, v145v2, t, "-")
-
-	v146v1 := map[uint64]string{10: "some-string"}
-	bs146, _ := testMarshalErr(v146v1, h, t, "-")
-	v146v2 := make(map[uint64]string)
-	testUnmarshalErr(v146v2, bs146, h, t, "-")
-	testDeepEqualErr(v146v1, v146v2, t, "-")
-	bs146, _ = testMarshalErr(&v146v1, h, t, "-")
-	v146v2 = nil
-	testUnmarshalErr(&v146v2, bs146, h, t, "-")
-	testDeepEqualErr(v146v1, v146v2, t, "-")
-
-	v147v1 := map[uint64]uint{10: 10}
-	bs147, _ := testMarshalErr(v147v1, h, t, "-")
-	v147v2 := make(map[uint64]uint)
-	testUnmarshalErr(v147v2, bs147, h, t, "-")
-	testDeepEqualErr(v147v1, v147v2, t, "-")
-	bs147, _ = testMarshalErr(&v147v1, h, t, "-")
-	v147v2 = nil
-	testUnmarshalErr(&v147v2, bs147, h, t, "-")
-	testDeepEqualErr(v147v1, v147v2, t, "-")
-
-	v148v1 := map[uint64]uint8{10: 10}
-	bs148, _ := testMarshalErr(v148v1, h, t, "-")
-	v148v2 := make(map[uint64]uint8)
-	testUnmarshalErr(v148v2, bs148, h, t, "-")
-	testDeepEqualErr(v148v1, v148v2, t, "-")
-	bs148, _ = testMarshalErr(&v148v1, h, t, "-")
-	v148v2 = nil
-	testUnmarshalErr(&v148v2, bs148, h, t, "-")
-	testDeepEqualErr(v148v1, v148v2, t, "-")
-
-	v149v1 := map[uint64]uint16{10: 10}
-	bs149, _ := testMarshalErr(v149v1, h, t, "-")
-	v149v2 := make(map[uint64]uint16)
-	testUnmarshalErr(v149v2, bs149, h, t, "-")
-	testDeepEqualErr(v149v1, v149v2, t, "-")
-	bs149, _ = testMarshalErr(&v149v1, h, t, "-")
-	v149v2 = nil
-	testUnmarshalErr(&v149v2, bs149, h, t, "-")
-	testDeepEqualErr(v149v1, v149v2, t, "-")
-
-	v150v1 := map[uint64]uint32{10: 10}
-	bs150, _ := testMarshalErr(v150v1, h, t, "-")
-	v150v2 := make(map[uint64]uint32)
-	testUnmarshalErr(v150v2, bs150, h, t, "-")
-	testDeepEqualErr(v150v1, v150v2, t, "-")
-	bs150, _ = testMarshalErr(&v150v1, h, t, "-")
-	v150v2 = nil
-	testUnmarshalErr(&v150v2, bs150, h, t, "-")
-	testDeepEqualErr(v150v1, v150v2, t, "-")
-
-	v151v1 := map[uint64]uint64{10: 10}
-	bs151, _ := testMarshalErr(v151v1, h, t, "-")
-	v151v2 := make(map[uint64]uint64)
-	testUnmarshalErr(v151v2, bs151, h, t, "-")
-	testDeepEqualErr(v151v1, v151v2, t, "-")
-	bs151, _ = testMarshalErr(&v151v1, h, t, "-")
-	v151v2 = nil
-	testUnmarshalErr(&v151v2, bs151, h, t, "-")
-	testDeepEqualErr(v151v1, v151v2, t, "-")
-
-	v152v1 := map[uint64]uintptr{10: 10}
-	bs152, _ := testMarshalErr(v152v1, h, t, "-")
-	v152v2 := make(map[uint64]uintptr)
-	testUnmarshalErr(v152v2, bs152, h, t, "-")
-	testDeepEqualErr(v152v1, v152v2, t, "-")
-	bs152, _ = testMarshalErr(&v152v1, h, t, "-")
-	v152v2 = nil
-	testUnmarshalErr(&v152v2, bs152, h, t, "-")
-	testDeepEqualErr(v152v1, v152v2, t, "-")
-
-	v153v1 := map[uint64]int{10: 10}
-	bs153, _ := testMarshalErr(v153v1, h, t, "-")
-	v153v2 := make(map[uint64]int)
-	testUnmarshalErr(v153v2, bs153, h, t, "-")
-	testDeepEqualErr(v153v1, v153v2, t, "-")
-	bs153, _ = testMarshalErr(&v153v1, h, t, "-")
-	v153v2 = nil
-	testUnmarshalErr(&v153v2, bs153, h, t, "-")
-	testDeepEqualErr(v153v1, v153v2, t, "-")
-
-	v154v1 := map[uint64]int8{10: 10}
-	bs154, _ := testMarshalErr(v154v1, h, t, "-")
-	v154v2 := make(map[uint64]int8)
-	testUnmarshalErr(v154v2, bs154, h, t, "-")
-	testDeepEqualErr(v154v1, v154v2, t, "-")
-	bs154, _ = testMarshalErr(&v154v1, h, t, "-")
-	v154v2 = nil
-	testUnmarshalErr(&v154v2, bs154, h, t, "-")
-	testDeepEqualErr(v154v1, v154v2, t, "-")
-
-	v155v1 := map[uint64]int16{10: 10}
-	bs155, _ := testMarshalErr(v155v1, h, t, "-")
-	v155v2 := make(map[uint64]int16)
-	testUnmarshalErr(v155v2, bs155, h, t, "-")
-	testDeepEqualErr(v155v1, v155v2, t, "-")
-	bs155, _ = testMarshalErr(&v155v1, h, t, "-")
-	v155v2 = nil
-	testUnmarshalErr(&v155v2, bs155, h, t, "-")
-	testDeepEqualErr(v155v1, v155v2, t, "-")
-
-	v156v1 := map[uint64]int32{10: 10}
-	bs156, _ := testMarshalErr(v156v1, h, t, "-")
-	v156v2 := make(map[uint64]int32)
-	testUnmarshalErr(v156v2, bs156, h, t, "-")
-	testDeepEqualErr(v156v1, v156v2, t, "-")
-	bs156, _ = testMarshalErr(&v156v1, h, t, "-")
-	v156v2 = nil
-	testUnmarshalErr(&v156v2, bs156, h, t, "-")
-	testDeepEqualErr(v156v1, v156v2, t, "-")
-
-	v157v1 := map[uint64]int64{10: 10}
-	bs157, _ := testMarshalErr(v157v1, h, t, "-")
-	v157v2 := make(map[uint64]int64)
-	testUnmarshalErr(v157v2, bs157, h, t, "-")
-	testDeepEqualErr(v157v1, v157v2, t, "-")
-	bs157, _ = testMarshalErr(&v157v1, h, t, "-")
-	v157v2 = nil
-	testUnmarshalErr(&v157v2, bs157, h, t, "-")
-	testDeepEqualErr(v157v1, v157v2, t, "-")
-
-	v158v1 := map[uint64]float32{10: 10.1}
-	bs158, _ := testMarshalErr(v158v1, h, t, "-")
-	v158v2 := make(map[uint64]float32)
-	testUnmarshalErr(v158v2, bs158, h, t, "-")
-	testDeepEqualErr(v158v1, v158v2, t, "-")
-	bs158, _ = testMarshalErr(&v158v1, h, t, "-")
-	v158v2 = nil
-	testUnmarshalErr(&v158v2, bs158, h, t, "-")
-	testDeepEqualErr(v158v1, v158v2, t, "-")
-
-	v159v1 := map[uint64]float64{10: 10.1}
-	bs159, _ := testMarshalErr(v159v1, h, t, "-")
-	v159v2 := make(map[uint64]float64)
-	testUnmarshalErr(v159v2, bs159, h, t, "-")
-	testDeepEqualErr(v159v1, v159v2, t, "-")
-	bs159, _ = testMarshalErr(&v159v1, h, t, "-")
-	v159v2 = nil
-	testUnmarshalErr(&v159v2, bs159, h, t, "-")
-	testDeepEqualErr(v159v1, v159v2, t, "-")
-
-	v160v1 := map[uint64]bool{10: true}
-	bs160, _ := testMarshalErr(v160v1, h, t, "-")
-	v160v2 := make(map[uint64]bool)
-	testUnmarshalErr(v160v2, bs160, h, t, "-")
-	testDeepEqualErr(v160v1, v160v2, t, "-")
-	bs160, _ = testMarshalErr(&v160v1, h, t, "-")
-	v160v2 = nil
-	testUnmarshalErr(&v160v2, bs160, h, t, "-")
-	testDeepEqualErr(v160v1, v160v2, t, "-")
-
-	v163v1 := map[uintptr]interface{}{10: "string-is-an-interface"}
-	bs163, _ := testMarshalErr(v163v1, h, t, "-")
-	v163v2 := make(map[uintptr]interface{})
-	testUnmarshalErr(v163v2, bs163, h, t, "-")
-	testDeepEqualErr(v163v1, v163v2, t, "-")
-	bs163, _ = testMarshalErr(&v163v1, h, t, "-")
-	v163v2 = nil
-	testUnmarshalErr(&v163v2, bs163, h, t, "-")
-	testDeepEqualErr(v163v1, v163v2, t, "-")
-
-	v164v1 := map[uintptr]string{10: "some-string"}
-	bs164, _ := testMarshalErr(v164v1, h, t, "-")
-	v164v2 := make(map[uintptr]string)
-	testUnmarshalErr(v164v2, bs164, h, t, "-")
-	testDeepEqualErr(v164v1, v164v2, t, "-")
-	bs164, _ = testMarshalErr(&v164v1, h, t, "-")
-	v164v2 = nil
-	testUnmarshalErr(&v164v2, bs164, h, t, "-")
-	testDeepEqualErr(v164v1, v164v2, t, "-")
-
-	v165v1 := map[uintptr]uint{10: 10}
-	bs165, _ := testMarshalErr(v165v1, h, t, "-")
-	v165v2 := make(map[uintptr]uint)
-	testUnmarshalErr(v165v2, bs165, h, t, "-")
-	testDeepEqualErr(v165v1, v165v2, t, "-")
-	bs165, _ = testMarshalErr(&v165v1, h, t, "-")
-	v165v2 = nil
-	testUnmarshalErr(&v165v2, bs165, h, t, "-")
-	testDeepEqualErr(v165v1, v165v2, t, "-")
-
-	v166v1 := map[uintptr]uint8{10: 10}
-	bs166, _ := testMarshalErr(v166v1, h, t, "-")
-	v166v2 := make(map[uintptr]uint8)
-	testUnmarshalErr(v166v2, bs166, h, t, "-")
-	testDeepEqualErr(v166v1, v166v2, t, "-")
-	bs166, _ = testMarshalErr(&v166v1, h, t, "-")
-	v166v2 = nil
-	testUnmarshalErr(&v166v2, bs166, h, t, "-")
-	testDeepEqualErr(v166v1, v166v2, t, "-")
-
-	v167v1 := map[uintptr]uint16{10: 10}
-	bs167, _ := testMarshalErr(v167v1, h, t, "-")
-	v167v2 := make(map[uintptr]uint16)
-	testUnmarshalErr(v167v2, bs167, h, t, "-")
-	testDeepEqualErr(v167v1, v167v2, t, "-")
-	bs167, _ = testMarshalErr(&v167v1, h, t, "-")
-	v167v2 = nil
-	testUnmarshalErr(&v167v2, bs167, h, t, "-")
-	testDeepEqualErr(v167v1, v167v2, t, "-")
-
-	v168v1 := map[uintptr]uint32{10: 10}
-	bs168, _ := testMarshalErr(v168v1, h, t, "-")
-	v168v2 := make(map[uintptr]uint32)
-	testUnmarshalErr(v168v2, bs168, h, t, "-")
-	testDeepEqualErr(v168v1, v168v2, t, "-")
-	bs168, _ = testMarshalErr(&v168v1, h, t, "-")
-	v168v2 = nil
-	testUnmarshalErr(&v168v2, bs168, h, t, "-")
-	testDeepEqualErr(v168v1, v168v2, t, "-")
-
-	v169v1 := map[uintptr]uint64{10: 10}
-	bs169, _ := testMarshalErr(v169v1, h, t, "-")
-	v169v2 := make(map[uintptr]uint64)
-	testUnmarshalErr(v169v2, bs169, h, t, "-")
-	testDeepEqualErr(v169v1, v169v2, t, "-")
-	bs169, _ = testMarshalErr(&v169v1, h, t, "-")
-	v169v2 = nil
-	testUnmarshalErr(&v169v2, bs169, h, t, "-")
-	testDeepEqualErr(v169v1, v169v2, t, "-")
-
-	v170v1 := map[uintptr]uintptr{10: 10}
-	bs170, _ := testMarshalErr(v170v1, h, t, "-")
-	v170v2 := make(map[uintptr]uintptr)
-	testUnmarshalErr(v170v2, bs170, h, t, "-")
-	testDeepEqualErr(v170v1, v170v2, t, "-")
-	bs170, _ = testMarshalErr(&v170v1, h, t, "-")
-	v170v2 = nil
-	testUnmarshalErr(&v170v2, bs170, h, t, "-")
-	testDeepEqualErr(v170v1, v170v2, t, "-")
-
-	v171v1 := map[uintptr]int{10: 10}
-	bs171, _ := testMarshalErr(v171v1, h, t, "-")
-	v171v2 := make(map[uintptr]int)
-	testUnmarshalErr(v171v2, bs171, h, t, "-")
-	testDeepEqualErr(v171v1, v171v2, t, "-")
-	bs171, _ = testMarshalErr(&v171v1, h, t, "-")
-	v171v2 = nil
-	testUnmarshalErr(&v171v2, bs171, h, t, "-")
-	testDeepEqualErr(v171v1, v171v2, t, "-")
-
-	v172v1 := map[uintptr]int8{10: 10}
-	bs172, _ := testMarshalErr(v172v1, h, t, "-")
-	v172v2 := make(map[uintptr]int8)
-	testUnmarshalErr(v172v2, bs172, h, t, "-")
-	testDeepEqualErr(v172v1, v172v2, t, "-")
-	bs172, _ = testMarshalErr(&v172v1, h, t, "-")
-	v172v2 = nil
-	testUnmarshalErr(&v172v2, bs172, h, t, "-")
-	testDeepEqualErr(v172v1, v172v2, t, "-")
-
-	v173v1 := map[uintptr]int16{10: 10}
-	bs173, _ := testMarshalErr(v173v1, h, t, "-")
-	v173v2 := make(map[uintptr]int16)
-	testUnmarshalErr(v173v2, bs173, h, t, "-")
-	testDeepEqualErr(v173v1, v173v2, t, "-")
-	bs173, _ = testMarshalErr(&v173v1, h, t, "-")
-	v173v2 = nil
-	testUnmarshalErr(&v173v2, bs173, h, t, "-")
-	testDeepEqualErr(v173v1, v173v2, t, "-")
-
-	v174v1 := map[uintptr]int32{10: 10}
-	bs174, _ := testMarshalErr(v174v1, h, t, "-")
-	v174v2 := make(map[uintptr]int32)
-	testUnmarshalErr(v174v2, bs174, h, t, "-")
-	testDeepEqualErr(v174v1, v174v2, t, "-")
-	bs174, _ = testMarshalErr(&v174v1, h, t, "-")
-	v174v2 = nil
-	testUnmarshalErr(&v174v2, bs174, h, t, "-")
-	testDeepEqualErr(v174v1, v174v2, t, "-")
-
-	v175v1 := map[uintptr]int64{10: 10}
-	bs175, _ := testMarshalErr(v175v1, h, t, "-")
-	v175v2 := make(map[uintptr]int64)
-	testUnmarshalErr(v175v2, bs175, h, t, "-")
-	testDeepEqualErr(v175v1, v175v2, t, "-")
-	bs175, _ = testMarshalErr(&v175v1, h, t, "-")
-	v175v2 = nil
-	testUnmarshalErr(&v175v2, bs175, h, t, "-")
-	testDeepEqualErr(v175v1, v175v2, t, "-")
-
-	v176v1 := map[uintptr]float32{10: 10.1}
-	bs176, _ := testMarshalErr(v176v1, h, t, "-")
-	v176v2 := make(map[uintptr]float32)
-	testUnmarshalErr(v176v2, bs176, h, t, "-")
-	testDeepEqualErr(v176v1, v176v2, t, "-")
-	bs176, _ = testMarshalErr(&v176v1, h, t, "-")
-	v176v2 = nil
-	testUnmarshalErr(&v176v2, bs176, h, t, "-")
-	testDeepEqualErr(v176v1, v176v2, t, "-")
-
-	v177v1 := map[uintptr]float64{10: 10.1}
-	bs177, _ := testMarshalErr(v177v1, h, t, "-")
-	v177v2 := make(map[uintptr]float64)
-	testUnmarshalErr(v177v2, bs177, h, t, "-")
-	testDeepEqualErr(v177v1, v177v2, t, "-")
-	bs177, _ = testMarshalErr(&v177v1, h, t, "-")
-	v177v2 = nil
-	testUnmarshalErr(&v177v2, bs177, h, t, "-")
-	testDeepEqualErr(v177v1, v177v2, t, "-")
-
-	v178v1 := map[uintptr]bool{10: true}
-	bs178, _ := testMarshalErr(v178v1, h, t, "-")
-	v178v2 := make(map[uintptr]bool)
-	testUnmarshalErr(v178v2, bs178, h, t, "-")
-	testDeepEqualErr(v178v1, v178v2, t, "-")
-	bs178, _ = testMarshalErr(&v178v1, h, t, "-")
-	v178v2 = nil
-	testUnmarshalErr(&v178v2, bs178, h, t, "-")
-	testDeepEqualErr(v178v1, v178v2, t, "-")
-
-	v181v1 := map[int]interface{}{10: "string-is-an-interface"}
-	bs181, _ := testMarshalErr(v181v1, h, t, "-")
-	v181v2 := make(map[int]interface{})
-	testUnmarshalErr(v181v2, bs181, h, t, "-")
-	testDeepEqualErr(v181v1, v181v2, t, "-")
-	bs181, _ = testMarshalErr(&v181v1, h, t, "-")
-	v181v2 = nil
-	testUnmarshalErr(&v181v2, bs181, h, t, "-")
-	testDeepEqualErr(v181v1, v181v2, t, "-")
-
-	v182v1 := map[int]string{10: "some-string"}
-	bs182, _ := testMarshalErr(v182v1, h, t, "-")
-	v182v2 := make(map[int]string)
-	testUnmarshalErr(v182v2, bs182, h, t, "-")
-	testDeepEqualErr(v182v1, v182v2, t, "-")
-	bs182, _ = testMarshalErr(&v182v1, h, t, "-")
-	v182v2 = nil
-	testUnmarshalErr(&v182v2, bs182, h, t, "-")
-	testDeepEqualErr(v182v1, v182v2, t, "-")
-
-	v183v1 := map[int]uint{10: 10}
-	bs183, _ := testMarshalErr(v183v1, h, t, "-")
-	v183v2 := make(map[int]uint)
-	testUnmarshalErr(v183v2, bs183, h, t, "-")
-	testDeepEqualErr(v183v1, v183v2, t, "-")
-	bs183, _ = testMarshalErr(&v183v1, h, t, "-")
-	v183v2 = nil
-	testUnmarshalErr(&v183v2, bs183, h, t, "-")
-	testDeepEqualErr(v183v1, v183v2, t, "-")
-
-	v184v1 := map[int]uint8{10: 10}
-	bs184, _ := testMarshalErr(v184v1, h, t, "-")
-	v184v2 := make(map[int]uint8)
-	testUnmarshalErr(v184v2, bs184, h, t, "-")
-	testDeepEqualErr(v184v1, v184v2, t, "-")
-	bs184, _ = testMarshalErr(&v184v1, h, t, "-")
-	v184v2 = nil
-	testUnmarshalErr(&v184v2, bs184, h, t, "-")
-	testDeepEqualErr(v184v1, v184v2, t, "-")
-
-	v185v1 := map[int]uint16{10: 10}
-	bs185, _ := testMarshalErr(v185v1, h, t, "-")
-	v185v2 := make(map[int]uint16)
-	testUnmarshalErr(v185v2, bs185, h, t, "-")
-	testDeepEqualErr(v185v1, v185v2, t, "-")
-	bs185, _ = testMarshalErr(&v185v1, h, t, "-")
-	v185v2 = nil
-	testUnmarshalErr(&v185v2, bs185, h, t, "-")
-	testDeepEqualErr(v185v1, v185v2, t, "-")
-
-	v186v1 := map[int]uint32{10: 10}
-	bs186, _ := testMarshalErr(v186v1, h, t, "-")
-	v186v2 := make(map[int]uint32)
-	testUnmarshalErr(v186v2, bs186, h, t, "-")
-	testDeepEqualErr(v186v1, v186v2, t, "-")
-	bs186, _ = testMarshalErr(&v186v1, h, t, "-")
-	v186v2 = nil
-	testUnmarshalErr(&v186v2, bs186, h, t, "-")
-	testDeepEqualErr(v186v1, v186v2, t, "-")
-
-	v187v1 := map[int]uint64{10: 10}
-	bs187, _ := testMarshalErr(v187v1, h, t, "-")
-	v187v2 := make(map[int]uint64)
-	testUnmarshalErr(v187v2, bs187, h, t, "-")
-	testDeepEqualErr(v187v1, v187v2, t, "-")
-	bs187, _ = testMarshalErr(&v187v1, h, t, "-")
-	v187v2 = nil
-	testUnmarshalErr(&v187v2, bs187, h, t, "-")
-	testDeepEqualErr(v187v1, v187v2, t, "-")
-
-	v188v1 := map[int]uintptr{10: 10}
-	bs188, _ := testMarshalErr(v188v1, h, t, "-")
-	v188v2 := make(map[int]uintptr)
-	testUnmarshalErr(v188v2, bs188, h, t, "-")
-	testDeepEqualErr(v188v1, v188v2, t, "-")
-	bs188, _ = testMarshalErr(&v188v1, h, t, "-")
-	v188v2 = nil
-	testUnmarshalErr(&v188v2, bs188, h, t, "-")
-	testDeepEqualErr(v188v1, v188v2, t, "-")
-
-	v189v1 := map[int]int{10: 10}
-	bs189, _ := testMarshalErr(v189v1, h, t, "-")
-	v189v2 := make(map[int]int)
-	testUnmarshalErr(v189v2, bs189, h, t, "-")
-	testDeepEqualErr(v189v1, v189v2, t, "-")
-	bs189, _ = testMarshalErr(&v189v1, h, t, "-")
-	v189v2 = nil
-	testUnmarshalErr(&v189v2, bs189, h, t, "-")
-	testDeepEqualErr(v189v1, v189v2, t, "-")
-
-	v190v1 := map[int]int8{10: 10}
-	bs190, _ := testMarshalErr(v190v1, h, t, "-")
-	v190v2 := make(map[int]int8)
-	testUnmarshalErr(v190v2, bs190, h, t, "-")
-	testDeepEqualErr(v190v1, v190v2, t, "-")
-	bs190, _ = testMarshalErr(&v190v1, h, t, "-")
-	v190v2 = nil
-	testUnmarshalErr(&v190v2, bs190, h, t, "-")
-	testDeepEqualErr(v190v1, v190v2, t, "-")
-
-	v191v1 := map[int]int16{10: 10}
-	bs191, _ := testMarshalErr(v191v1, h, t, "-")
-	v191v2 := make(map[int]int16)
-	testUnmarshalErr(v191v2, bs191, h, t, "-")
-	testDeepEqualErr(v191v1, v191v2, t, "-")
-	bs191, _ = testMarshalErr(&v191v1, h, t, "-")
-	v191v2 = nil
-	testUnmarshalErr(&v191v2, bs191, h, t, "-")
-	testDeepEqualErr(v191v1, v191v2, t, "-")
-
-	v192v1 := map[int]int32{10: 10}
-	bs192, _ := testMarshalErr(v192v1, h, t, "-")
-	v192v2 := make(map[int]int32)
-	testUnmarshalErr(v192v2, bs192, h, t, "-")
-	testDeepEqualErr(v192v1, v192v2, t, "-")
-	bs192, _ = testMarshalErr(&v192v1, h, t, "-")
-	v192v2 = nil
-	testUnmarshalErr(&v192v2, bs192, h, t, "-")
-	testDeepEqualErr(v192v1, v192v2, t, "-")
-
-	v193v1 := map[int]int64{10: 10}
-	bs193, _ := testMarshalErr(v193v1, h, t, "-")
-	v193v2 := make(map[int]int64)
-	testUnmarshalErr(v193v2, bs193, h, t, "-")
-	testDeepEqualErr(v193v1, v193v2, t, "-")
-	bs193, _ = testMarshalErr(&v193v1, h, t, "-")
-	v193v2 = nil
-	testUnmarshalErr(&v193v2, bs193, h, t, "-")
-	testDeepEqualErr(v193v1, v193v2, t, "-")
-
-	v194v1 := map[int]float32{10: 10.1}
-	bs194, _ := testMarshalErr(v194v1, h, t, "-")
-	v194v2 := make(map[int]float32)
-	testUnmarshalErr(v194v2, bs194, h, t, "-")
-	testDeepEqualErr(v194v1, v194v2, t, "-")
-	bs194, _ = testMarshalErr(&v194v1, h, t, "-")
-	v194v2 = nil
-	testUnmarshalErr(&v194v2, bs194, h, t, "-")
-	testDeepEqualErr(v194v1, v194v2, t, "-")
-
-	v195v1 := map[int]float64{10: 10.1}
-	bs195, _ := testMarshalErr(v195v1, h, t, "-")
-	v195v2 := make(map[int]float64)
-	testUnmarshalErr(v195v2, bs195, h, t, "-")
-	testDeepEqualErr(v195v1, v195v2, t, "-")
-	bs195, _ = testMarshalErr(&v195v1, h, t, "-")
-	v195v2 = nil
-	testUnmarshalErr(&v195v2, bs195, h, t, "-")
-	testDeepEqualErr(v195v1, v195v2, t, "-")
-
-	v196v1 := map[int]bool{10: true}
-	bs196, _ := testMarshalErr(v196v1, h, t, "-")
-	v196v2 := make(map[int]bool)
-	testUnmarshalErr(v196v2, bs196, h, t, "-")
-	testDeepEqualErr(v196v1, v196v2, t, "-")
-	bs196, _ = testMarshalErr(&v196v1, h, t, "-")
-	v196v2 = nil
-	testUnmarshalErr(&v196v2, bs196, h, t, "-")
-	testDeepEqualErr(v196v1, v196v2, t, "-")
-
-	v199v1 := map[int8]interface{}{10: "string-is-an-interface"}
-	bs199, _ := testMarshalErr(v199v1, h, t, "-")
-	v199v2 := make(map[int8]interface{})
-	testUnmarshalErr(v199v2, bs199, h, t, "-")
-	testDeepEqualErr(v199v1, v199v2, t, "-")
-	bs199, _ = testMarshalErr(&v199v1, h, t, "-")
-	v199v2 = nil
-	testUnmarshalErr(&v199v2, bs199, h, t, "-")
-	testDeepEqualErr(v199v1, v199v2, t, "-")
-
-	v200v1 := map[int8]string{10: "some-string"}
-	bs200, _ := testMarshalErr(v200v1, h, t, "-")
-	v200v2 := make(map[int8]string)
-	testUnmarshalErr(v200v2, bs200, h, t, "-")
-	testDeepEqualErr(v200v1, v200v2, t, "-")
-	bs200, _ = testMarshalErr(&v200v1, h, t, "-")
-	v200v2 = nil
-	testUnmarshalErr(&v200v2, bs200, h, t, "-")
-	testDeepEqualErr(v200v1, v200v2, t, "-")
-
-	v201v1 := map[int8]uint{10: 10}
-	bs201, _ := testMarshalErr(v201v1, h, t, "-")
-	v201v2 := make(map[int8]uint)
-	testUnmarshalErr(v201v2, bs201, h, t, "-")
-	testDeepEqualErr(v201v1, v201v2, t, "-")
-	bs201, _ = testMarshalErr(&v201v1, h, t, "-")
-	v201v2 = nil
-	testUnmarshalErr(&v201v2, bs201, h, t, "-")
-	testDeepEqualErr(v201v1, v201v2, t, "-")
-
-	v202v1 := map[int8]uint8{10: 10}
-	bs202, _ := testMarshalErr(v202v1, h, t, "-")
-	v202v2 := make(map[int8]uint8)
-	testUnmarshalErr(v202v2, bs202, h, t, "-")
-	testDeepEqualErr(v202v1, v202v2, t, "-")
-	bs202, _ = testMarshalErr(&v202v1, h, t, "-")
-	v202v2 = nil
-	testUnmarshalErr(&v202v2, bs202, h, t, "-")
-	testDeepEqualErr(v202v1, v202v2, t, "-")
-
-	v203v1 := map[int8]uint16{10: 10}
-	bs203, _ := testMarshalErr(v203v1, h, t, "-")
-	v203v2 := make(map[int8]uint16)
-	testUnmarshalErr(v203v2, bs203, h, t, "-")
-	testDeepEqualErr(v203v1, v203v2, t, "-")
-	bs203, _ = testMarshalErr(&v203v1, h, t, "-")
-	v203v2 = nil
-	testUnmarshalErr(&v203v2, bs203, h, t, "-")
-	testDeepEqualErr(v203v1, v203v2, t, "-")
-
-	v204v1 := map[int8]uint32{10: 10}
-	bs204, _ := testMarshalErr(v204v1, h, t, "-")
-	v204v2 := make(map[int8]uint32)
-	testUnmarshalErr(v204v2, bs204, h, t, "-")
-	testDeepEqualErr(v204v1, v204v2, t, "-")
-	bs204, _ = testMarshalErr(&v204v1, h, t, "-")
-	v204v2 = nil
-	testUnmarshalErr(&v204v2, bs204, h, t, "-")
-	testDeepEqualErr(v204v1, v204v2, t, "-")
-
-	v205v1 := map[int8]uint64{10: 10}
-	bs205, _ := testMarshalErr(v205v1, h, t, "-")
-	v205v2 := make(map[int8]uint64)
-	testUnmarshalErr(v205v2, bs205, h, t, "-")
-	testDeepEqualErr(v205v1, v205v2, t, "-")
-	bs205, _ = testMarshalErr(&v205v1, h, t, "-")
-	v205v2 = nil
-	testUnmarshalErr(&v205v2, bs205, h, t, "-")
-	testDeepEqualErr(v205v1, v205v2, t, "-")
-
-	v206v1 := map[int8]uintptr{10: 10}
-	bs206, _ := testMarshalErr(v206v1, h, t, "-")
-	v206v2 := make(map[int8]uintptr)
-	testUnmarshalErr(v206v2, bs206, h, t, "-")
-	testDeepEqualErr(v206v1, v206v2, t, "-")
-	bs206, _ = testMarshalErr(&v206v1, h, t, "-")
-	v206v2 = nil
-	testUnmarshalErr(&v206v2, bs206, h, t, "-")
-	testDeepEqualErr(v206v1, v206v2, t, "-")
-
-	v207v1 := map[int8]int{10: 10}
-	bs207, _ := testMarshalErr(v207v1, h, t, "-")
-	v207v2 := make(map[int8]int)
-	testUnmarshalErr(v207v2, bs207, h, t, "-")
-	testDeepEqualErr(v207v1, v207v2, t, "-")
-	bs207, _ = testMarshalErr(&v207v1, h, t, "-")
-	v207v2 = nil
-	testUnmarshalErr(&v207v2, bs207, h, t, "-")
-	testDeepEqualErr(v207v1, v207v2, t, "-")
-
-	v208v1 := map[int8]int8{10: 10}
-	bs208, _ := testMarshalErr(v208v1, h, t, "-")
-	v208v2 := make(map[int8]int8)
-	testUnmarshalErr(v208v2, bs208, h, t, "-")
-	testDeepEqualErr(v208v1, v208v2, t, "-")
-	bs208, _ = testMarshalErr(&v208v1, h, t, "-")
-	v208v2 = nil
-	testUnmarshalErr(&v208v2, bs208, h, t, "-")
-	testDeepEqualErr(v208v1, v208v2, t, "-")
-
-	v209v1 := map[int8]int16{10: 10}
-	bs209, _ := testMarshalErr(v209v1, h, t, "-")
-	v209v2 := make(map[int8]int16)
-	testUnmarshalErr(v209v2, bs209, h, t, "-")
-	testDeepEqualErr(v209v1, v209v2, t, "-")
-	bs209, _ = testMarshalErr(&v209v1, h, t, "-")
-	v209v2 = nil
-	testUnmarshalErr(&v209v2, bs209, h, t, "-")
-	testDeepEqualErr(v209v1, v209v2, t, "-")
-
-	v210v1 := map[int8]int32{10: 10}
-	bs210, _ := testMarshalErr(v210v1, h, t, "-")
-	v210v2 := make(map[int8]int32)
-	testUnmarshalErr(v210v2, bs210, h, t, "-")
-	testDeepEqualErr(v210v1, v210v2, t, "-")
-	bs210, _ = testMarshalErr(&v210v1, h, t, "-")
-	v210v2 = nil
-	testUnmarshalErr(&v210v2, bs210, h, t, "-")
-	testDeepEqualErr(v210v1, v210v2, t, "-")
-
-	v211v1 := map[int8]int64{10: 10}
-	bs211, _ := testMarshalErr(v211v1, h, t, "-")
-	v211v2 := make(map[int8]int64)
-	testUnmarshalErr(v211v2, bs211, h, t, "-")
-	testDeepEqualErr(v211v1, v211v2, t, "-")
-	bs211, _ = testMarshalErr(&v211v1, h, t, "-")
-	v211v2 = nil
-	testUnmarshalErr(&v211v2, bs211, h, t, "-")
-	testDeepEqualErr(v211v1, v211v2, t, "-")
-
-	v212v1 := map[int8]float32{10: 10.1}
-	bs212, _ := testMarshalErr(v212v1, h, t, "-")
-	v212v2 := make(map[int8]float32)
-	testUnmarshalErr(v212v2, bs212, h, t, "-")
-	testDeepEqualErr(v212v1, v212v2, t, "-")
-	bs212, _ = testMarshalErr(&v212v1, h, t, "-")
-	v212v2 = nil
-	testUnmarshalErr(&v212v2, bs212, h, t, "-")
-	testDeepEqualErr(v212v1, v212v2, t, "-")
-
-	v213v1 := map[int8]float64{10: 10.1}
-	bs213, _ := testMarshalErr(v213v1, h, t, "-")
-	v213v2 := make(map[int8]float64)
-	testUnmarshalErr(v213v2, bs213, h, t, "-")
-	testDeepEqualErr(v213v1, v213v2, t, "-")
-	bs213, _ = testMarshalErr(&v213v1, h, t, "-")
-	v213v2 = nil
-	testUnmarshalErr(&v213v2, bs213, h, t, "-")
-	testDeepEqualErr(v213v1, v213v2, t, "-")
-
-	v214v1 := map[int8]bool{10: true}
-	bs214, _ := testMarshalErr(v214v1, h, t, "-")
-	v214v2 := make(map[int8]bool)
-	testUnmarshalErr(v214v2, bs214, h, t, "-")
-	testDeepEqualErr(v214v1, v214v2, t, "-")
-	bs214, _ = testMarshalErr(&v214v1, h, t, "-")
-	v214v2 = nil
-	testUnmarshalErr(&v214v2, bs214, h, t, "-")
-	testDeepEqualErr(v214v1, v214v2, t, "-")
-
-	v217v1 := map[int16]interface{}{10: "string-is-an-interface"}
-	bs217, _ := testMarshalErr(v217v1, h, t, "-")
-	v217v2 := make(map[int16]interface{})
-	testUnmarshalErr(v217v2, bs217, h, t, "-")
-	testDeepEqualErr(v217v1, v217v2, t, "-")
-	bs217, _ = testMarshalErr(&v217v1, h, t, "-")
-	v217v2 = nil
-	testUnmarshalErr(&v217v2, bs217, h, t, "-")
-	testDeepEqualErr(v217v1, v217v2, t, "-")
-
-	v218v1 := map[int16]string{10: "some-string"}
-	bs218, _ := testMarshalErr(v218v1, h, t, "-")
-	v218v2 := make(map[int16]string)
-	testUnmarshalErr(v218v2, bs218, h, t, "-")
-	testDeepEqualErr(v218v1, v218v2, t, "-")
-	bs218, _ = testMarshalErr(&v218v1, h, t, "-")
-	v218v2 = nil
-	testUnmarshalErr(&v218v2, bs218, h, t, "-")
-	testDeepEqualErr(v218v1, v218v2, t, "-")
-
-	v219v1 := map[int16]uint{10: 10}
-	bs219, _ := testMarshalErr(v219v1, h, t, "-")
-	v219v2 := make(map[int16]uint)
-	testUnmarshalErr(v219v2, bs219, h, t, "-")
-	testDeepEqualErr(v219v1, v219v2, t, "-")
-	bs219, _ = testMarshalErr(&v219v1, h, t, "-")
-	v219v2 = nil
-	testUnmarshalErr(&v219v2, bs219, h, t, "-")
-	testDeepEqualErr(v219v1, v219v2, t, "-")
-
-	v220v1 := map[int16]uint8{10: 10}
-	bs220, _ := testMarshalErr(v220v1, h, t, "-")
-	v220v2 := make(map[int16]uint8)
-	testUnmarshalErr(v220v2, bs220, h, t, "-")
-	testDeepEqualErr(v220v1, v220v2, t, "-")
-	bs220, _ = testMarshalErr(&v220v1, h, t, "-")
-	v220v2 = nil
-	testUnmarshalErr(&v220v2, bs220, h, t, "-")
-	testDeepEqualErr(v220v1, v220v2, t, "-")
-
-	v221v1 := map[int16]uint16{10: 10}
-	bs221, _ := testMarshalErr(v221v1, h, t, "-")
-	v221v2 := make(map[int16]uint16)
-	testUnmarshalErr(v221v2, bs221, h, t, "-")
-	testDeepEqualErr(v221v1, v221v2, t, "-")
-	bs221, _ = testMarshalErr(&v221v1, h, t, "-")
-	v221v2 = nil
-	testUnmarshalErr(&v221v2, bs221, h, t, "-")
-	testDeepEqualErr(v221v1, v221v2, t, "-")
-
-	v222v1 := map[int16]uint32{10: 10}
-	bs222, _ := testMarshalErr(v222v1, h, t, "-")
-	v222v2 := make(map[int16]uint32)
-	testUnmarshalErr(v222v2, bs222, h, t, "-")
-	testDeepEqualErr(v222v1, v222v2, t, "-")
-	bs222, _ = testMarshalErr(&v222v1, h, t, "-")
-	v222v2 = nil
-	testUnmarshalErr(&v222v2, bs222, h, t, "-")
-	testDeepEqualErr(v222v1, v222v2, t, "-")
-
-	v223v1 := map[int16]uint64{10: 10}
-	bs223, _ := testMarshalErr(v223v1, h, t, "-")
-	v223v2 := make(map[int16]uint64)
-	testUnmarshalErr(v223v2, bs223, h, t, "-")
-	testDeepEqualErr(v223v1, v223v2, t, "-")
-	bs223, _ = testMarshalErr(&v223v1, h, t, "-")
-	v223v2 = nil
-	testUnmarshalErr(&v223v2, bs223, h, t, "-")
-	testDeepEqualErr(v223v1, v223v2, t, "-")
-
-	v224v1 := map[int16]uintptr{10: 10}
-	bs224, _ := testMarshalErr(v224v1, h, t, "-")
-	v224v2 := make(map[int16]uintptr)
-	testUnmarshalErr(v224v2, bs224, h, t, "-")
-	testDeepEqualErr(v224v1, v224v2, t, "-")
-	bs224, _ = testMarshalErr(&v224v1, h, t, "-")
-	v224v2 = nil
-	testUnmarshalErr(&v224v2, bs224, h, t, "-")
-	testDeepEqualErr(v224v1, v224v2, t, "-")
-
-	v225v1 := map[int16]int{10: 10}
-	bs225, _ := testMarshalErr(v225v1, h, t, "-")
-	v225v2 := make(map[int16]int)
-	testUnmarshalErr(v225v2, bs225, h, t, "-")
-	testDeepEqualErr(v225v1, v225v2, t, "-")
-	bs225, _ = testMarshalErr(&v225v1, h, t, "-")
-	v225v2 = nil
-	testUnmarshalErr(&v225v2, bs225, h, t, "-")
-	testDeepEqualErr(v225v1, v225v2, t, "-")
-
-	v226v1 := map[int16]int8{10: 10}
-	bs226, _ := testMarshalErr(v226v1, h, t, "-")
-	v226v2 := make(map[int16]int8)
-	testUnmarshalErr(v226v2, bs226, h, t, "-")
-	testDeepEqualErr(v226v1, v226v2, t, "-")
-	bs226, _ = testMarshalErr(&v226v1, h, t, "-")
-	v226v2 = nil
-	testUnmarshalErr(&v226v2, bs226, h, t, "-")
-	testDeepEqualErr(v226v1, v226v2, t, "-")
-
-	v227v1 := map[int16]int16{10: 10}
-	bs227, _ := testMarshalErr(v227v1, h, t, "-")
-	v227v2 := make(map[int16]int16)
-	testUnmarshalErr(v227v2, bs227, h, t, "-")
-	testDeepEqualErr(v227v1, v227v2, t, "-")
-	bs227, _ = testMarshalErr(&v227v1, h, t, "-")
-	v227v2 = nil
-	testUnmarshalErr(&v227v2, bs227, h, t, "-")
-	testDeepEqualErr(v227v1, v227v2, t, "-")
-
-	v228v1 := map[int16]int32{10: 10}
-	bs228, _ := testMarshalErr(v228v1, h, t, "-")
-	v228v2 := make(map[int16]int32)
-	testUnmarshalErr(v228v2, bs228, h, t, "-")
-	testDeepEqualErr(v228v1, v228v2, t, "-")
-	bs228, _ = testMarshalErr(&v228v1, h, t, "-")
-	v228v2 = nil
-	testUnmarshalErr(&v228v2, bs228, h, t, "-")
-	testDeepEqualErr(v228v1, v228v2, t, "-")
-
-	v229v1 := map[int16]int64{10: 10}
-	bs229, _ := testMarshalErr(v229v1, h, t, "-")
-	v229v2 := make(map[int16]int64)
-	testUnmarshalErr(v229v2, bs229, h, t, "-")
-	testDeepEqualErr(v229v1, v229v2, t, "-")
-	bs229, _ = testMarshalErr(&v229v1, h, t, "-")
-	v229v2 = nil
-	testUnmarshalErr(&v229v2, bs229, h, t, "-")
-	testDeepEqualErr(v229v1, v229v2, t, "-")
-
-	v230v1 := map[int16]float32{10: 10.1}
-	bs230, _ := testMarshalErr(v230v1, h, t, "-")
-	v230v2 := make(map[int16]float32)
-	testUnmarshalErr(v230v2, bs230, h, t, "-")
-	testDeepEqualErr(v230v1, v230v2, t, "-")
-	bs230, _ = testMarshalErr(&v230v1, h, t, "-")
-	v230v2 = nil
-	testUnmarshalErr(&v230v2, bs230, h, t, "-")
-	testDeepEqualErr(v230v1, v230v2, t, "-")
-
-	v231v1 := map[int16]float64{10: 10.1}
-	bs231, _ := testMarshalErr(v231v1, h, t, "-")
-	v231v2 := make(map[int16]float64)
-	testUnmarshalErr(v231v2, bs231, h, t, "-")
-	testDeepEqualErr(v231v1, v231v2, t, "-")
-	bs231, _ = testMarshalErr(&v231v1, h, t, "-")
-	v231v2 = nil
-	testUnmarshalErr(&v231v2, bs231, h, t, "-")
-	testDeepEqualErr(v231v1, v231v2, t, "-")
-
-	v232v1 := map[int16]bool{10: true}
-	bs232, _ := testMarshalErr(v232v1, h, t, "-")
-	v232v2 := make(map[int16]bool)
-	testUnmarshalErr(v232v2, bs232, h, t, "-")
-	testDeepEqualErr(v232v1, v232v2, t, "-")
-	bs232, _ = testMarshalErr(&v232v1, h, t, "-")
-	v232v2 = nil
-	testUnmarshalErr(&v232v2, bs232, h, t, "-")
-	testDeepEqualErr(v232v1, v232v2, t, "-")
-
-	v235v1 := map[int32]interface{}{10: "string-is-an-interface"}
-	bs235, _ := testMarshalErr(v235v1, h, t, "-")
-	v235v2 := make(map[int32]interface{})
-	testUnmarshalErr(v235v2, bs235, h, t, "-")
-	testDeepEqualErr(v235v1, v235v2, t, "-")
-	bs235, _ = testMarshalErr(&v235v1, h, t, "-")
-	v235v2 = nil
-	testUnmarshalErr(&v235v2, bs235, h, t, "-")
-	testDeepEqualErr(v235v1, v235v2, t, "-")
-
-	v236v1 := map[int32]string{10: "some-string"}
-	bs236, _ := testMarshalErr(v236v1, h, t, "-")
-	v236v2 := make(map[int32]string)
-	testUnmarshalErr(v236v2, bs236, h, t, "-")
-	testDeepEqualErr(v236v1, v236v2, t, "-")
-	bs236, _ = testMarshalErr(&v236v1, h, t, "-")
-	v236v2 = nil
-	testUnmarshalErr(&v236v2, bs236, h, t, "-")
-	testDeepEqualErr(v236v1, v236v2, t, "-")
-
-	v237v1 := map[int32]uint{10: 10}
-	bs237, _ := testMarshalErr(v237v1, h, t, "-")
-	v237v2 := make(map[int32]uint)
-	testUnmarshalErr(v237v2, bs237, h, t, "-")
-	testDeepEqualErr(v237v1, v237v2, t, "-")
-	bs237, _ = testMarshalErr(&v237v1, h, t, "-")
-	v237v2 = nil
-	testUnmarshalErr(&v237v2, bs237, h, t, "-")
-	testDeepEqualErr(v237v1, v237v2, t, "-")
-
-	v238v1 := map[int32]uint8{10: 10}
-	bs238, _ := testMarshalErr(v238v1, h, t, "-")
-	v238v2 := make(map[int32]uint8)
-	testUnmarshalErr(v238v2, bs238, h, t, "-")
-	testDeepEqualErr(v238v1, v238v2, t, "-")
-	bs238, _ = testMarshalErr(&v238v1, h, t, "-")
-	v238v2 = nil
-	testUnmarshalErr(&v238v2, bs238, h, t, "-")
-	testDeepEqualErr(v238v1, v238v2, t, "-")
-
-	v239v1 := map[int32]uint16{10: 10}
-	bs239, _ := testMarshalErr(v239v1, h, t, "-")
-	v239v2 := make(map[int32]uint16)
-	testUnmarshalErr(v239v2, bs239, h, t, "-")
-	testDeepEqualErr(v239v1, v239v2, t, "-")
-	bs239, _ = testMarshalErr(&v239v1, h, t, "-")
-	v239v2 = nil
-	testUnmarshalErr(&v239v2, bs239, h, t, "-")
-	testDeepEqualErr(v239v1, v239v2, t, "-")
-
-	v240v1 := map[int32]uint32{10: 10}
-	bs240, _ := testMarshalErr(v240v1, h, t, "-")
-	v240v2 := make(map[int32]uint32)
-	testUnmarshalErr(v240v2, bs240, h, t, "-")
-	testDeepEqualErr(v240v1, v240v2, t, "-")
-	bs240, _ = testMarshalErr(&v240v1, h, t, "-")
-	v240v2 = nil
-	testUnmarshalErr(&v240v2, bs240, h, t, "-")
-	testDeepEqualErr(v240v1, v240v2, t, "-")
-
-	v241v1 := map[int32]uint64{10: 10}
-	bs241, _ := testMarshalErr(v241v1, h, t, "-")
-	v241v2 := make(map[int32]uint64)
-	testUnmarshalErr(v241v2, bs241, h, t, "-")
-	testDeepEqualErr(v241v1, v241v2, t, "-")
-	bs241, _ = testMarshalErr(&v241v1, h, t, "-")
-	v241v2 = nil
-	testUnmarshalErr(&v241v2, bs241, h, t, "-")
-	testDeepEqualErr(v241v1, v241v2, t, "-")
-
-	v242v1 := map[int32]uintptr{10: 10}
-	bs242, _ := testMarshalErr(v242v1, h, t, "-")
-	v242v2 := make(map[int32]uintptr)
-	testUnmarshalErr(v242v2, bs242, h, t, "-")
-	testDeepEqualErr(v242v1, v242v2, t, "-")
-	bs242, _ = testMarshalErr(&v242v1, h, t, "-")
-	v242v2 = nil
-	testUnmarshalErr(&v242v2, bs242, h, t, "-")
-	testDeepEqualErr(v242v1, v242v2, t, "-")
-
-	v243v1 := map[int32]int{10: 10}
-	bs243, _ := testMarshalErr(v243v1, h, t, "-")
-	v243v2 := make(map[int32]int)
-	testUnmarshalErr(v243v2, bs243, h, t, "-")
-	testDeepEqualErr(v243v1, v243v2, t, "-")
-	bs243, _ = testMarshalErr(&v243v1, h, t, "-")
-	v243v2 = nil
-	testUnmarshalErr(&v243v2, bs243, h, t, "-")
-	testDeepEqualErr(v243v1, v243v2, t, "-")
-
-	v244v1 := map[int32]int8{10: 10}
-	bs244, _ := testMarshalErr(v244v1, h, t, "-")
-	v244v2 := make(map[int32]int8)
-	testUnmarshalErr(v244v2, bs244, h, t, "-")
-	testDeepEqualErr(v244v1, v244v2, t, "-")
-	bs244, _ = testMarshalErr(&v244v1, h, t, "-")
-	v244v2 = nil
-	testUnmarshalErr(&v244v2, bs244, h, t, "-")
-	testDeepEqualErr(v244v1, v244v2, t, "-")
-
-	v245v1 := map[int32]int16{10: 10}
-	bs245, _ := testMarshalErr(v245v1, h, t, "-")
-	v245v2 := make(map[int32]int16)
-	testUnmarshalErr(v245v2, bs245, h, t, "-")
-	testDeepEqualErr(v245v1, v245v2, t, "-")
-	bs245, _ = testMarshalErr(&v245v1, h, t, "-")
-	v245v2 = nil
-	testUnmarshalErr(&v245v2, bs245, h, t, "-")
-	testDeepEqualErr(v245v1, v245v2, t, "-")
-
-	v246v1 := map[int32]int32{10: 10}
-	bs246, _ := testMarshalErr(v246v1, h, t, "-")
-	v246v2 := make(map[int32]int32)
-	testUnmarshalErr(v246v2, bs246, h, t, "-")
-	testDeepEqualErr(v246v1, v246v2, t, "-")
-	bs246, _ = testMarshalErr(&v246v1, h, t, "-")
-	v246v2 = nil
-	testUnmarshalErr(&v246v2, bs246, h, t, "-")
-	testDeepEqualErr(v246v1, v246v2, t, "-")
-
-	v247v1 := map[int32]int64{10: 10}
-	bs247, _ := testMarshalErr(v247v1, h, t, "-")
-	v247v2 := make(map[int32]int64)
-	testUnmarshalErr(v247v2, bs247, h, t, "-")
-	testDeepEqualErr(v247v1, v247v2, t, "-")
-	bs247, _ = testMarshalErr(&v247v1, h, t, "-")
-	v247v2 = nil
-	testUnmarshalErr(&v247v2, bs247, h, t, "-")
-	testDeepEqualErr(v247v1, v247v2, t, "-")
-
-	v248v1 := map[int32]float32{10: 10.1}
-	bs248, _ := testMarshalErr(v248v1, h, t, "-")
-	v248v2 := make(map[int32]float32)
-	testUnmarshalErr(v248v2, bs248, h, t, "-")
-	testDeepEqualErr(v248v1, v248v2, t, "-")
-	bs248, _ = testMarshalErr(&v248v1, h, t, "-")
-	v248v2 = nil
-	testUnmarshalErr(&v248v2, bs248, h, t, "-")
-	testDeepEqualErr(v248v1, v248v2, t, "-")
-
-	v249v1 := map[int32]float64{10: 10.1}
-	bs249, _ := testMarshalErr(v249v1, h, t, "-")
-	v249v2 := make(map[int32]float64)
-	testUnmarshalErr(v249v2, bs249, h, t, "-")
-	testDeepEqualErr(v249v1, v249v2, t, "-")
-	bs249, _ = testMarshalErr(&v249v1, h, t, "-")
-	v249v2 = nil
-	testUnmarshalErr(&v249v2, bs249, h, t, "-")
-	testDeepEqualErr(v249v1, v249v2, t, "-")
-
-	v250v1 := map[int32]bool{10: true}
-	bs250, _ := testMarshalErr(v250v1, h, t, "-")
-	v250v2 := make(map[int32]bool)
-	testUnmarshalErr(v250v2, bs250, h, t, "-")
-	testDeepEqualErr(v250v1, v250v2, t, "-")
-	bs250, _ = testMarshalErr(&v250v1, h, t, "-")
-	v250v2 = nil
-	testUnmarshalErr(&v250v2, bs250, h, t, "-")
-	testDeepEqualErr(v250v1, v250v2, t, "-")
-
-	v253v1 := map[int64]interface{}{10: "string-is-an-interface"}
-	bs253, _ := testMarshalErr(v253v1, h, t, "-")
-	v253v2 := make(map[int64]interface{})
-	testUnmarshalErr(v253v2, bs253, h, t, "-")
-	testDeepEqualErr(v253v1, v253v2, t, "-")
-	bs253, _ = testMarshalErr(&v253v1, h, t, "-")
-	v253v2 = nil
-	testUnmarshalErr(&v253v2, bs253, h, t, "-")
-	testDeepEqualErr(v253v1, v253v2, t, "-")
-
-	v254v1 := map[int64]string{10: "some-string"}
-	bs254, _ := testMarshalErr(v254v1, h, t, "-")
-	v254v2 := make(map[int64]string)
-	testUnmarshalErr(v254v2, bs254, h, t, "-")
-	testDeepEqualErr(v254v1, v254v2, t, "-")
-	bs254, _ = testMarshalErr(&v254v1, h, t, "-")
-	v254v2 = nil
-	testUnmarshalErr(&v254v2, bs254, h, t, "-")
-	testDeepEqualErr(v254v1, v254v2, t, "-")
-
-	v255v1 := map[int64]uint{10: 10}
-	bs255, _ := testMarshalErr(v255v1, h, t, "-")
-	v255v2 := make(map[int64]uint)
-	testUnmarshalErr(v255v2, bs255, h, t, "-")
-	testDeepEqualErr(v255v1, v255v2, t, "-")
-	bs255, _ = testMarshalErr(&v255v1, h, t, "-")
-	v255v2 = nil
-	testUnmarshalErr(&v255v2, bs255, h, t, "-")
-	testDeepEqualErr(v255v1, v255v2, t, "-")
-
-	v256v1 := map[int64]uint8{10: 10}
-	bs256, _ := testMarshalErr(v256v1, h, t, "-")
-	v256v2 := make(map[int64]uint8)
-	testUnmarshalErr(v256v2, bs256, h, t, "-")
-	testDeepEqualErr(v256v1, v256v2, t, "-")
-	bs256, _ = testMarshalErr(&v256v1, h, t, "-")
-	v256v2 = nil
-	testUnmarshalErr(&v256v2, bs256, h, t, "-")
-	testDeepEqualErr(v256v1, v256v2, t, "-")
-
-	v257v1 := map[int64]uint16{10: 10}
-	bs257, _ := testMarshalErr(v257v1, h, t, "-")
-	v257v2 := make(map[int64]uint16)
-	testUnmarshalErr(v257v2, bs257, h, t, "-")
-	testDeepEqualErr(v257v1, v257v2, t, "-")
-	bs257, _ = testMarshalErr(&v257v1, h, t, "-")
-	v257v2 = nil
-	testUnmarshalErr(&v257v2, bs257, h, t, "-")
-	testDeepEqualErr(v257v1, v257v2, t, "-")
-
-	v258v1 := map[int64]uint32{10: 10}
-	bs258, _ := testMarshalErr(v258v1, h, t, "-")
-	v258v2 := make(map[int64]uint32)
-	testUnmarshalErr(v258v2, bs258, h, t, "-")
-	testDeepEqualErr(v258v1, v258v2, t, "-")
-	bs258, _ = testMarshalErr(&v258v1, h, t, "-")
-	v258v2 = nil
-	testUnmarshalErr(&v258v2, bs258, h, t, "-")
-	testDeepEqualErr(v258v1, v258v2, t, "-")
-
-	v259v1 := map[int64]uint64{10: 10}
-	bs259, _ := testMarshalErr(v259v1, h, t, "-")
-	v259v2 := make(map[int64]uint64)
-	testUnmarshalErr(v259v2, bs259, h, t, "-")
-	testDeepEqualErr(v259v1, v259v2, t, "-")
-	bs259, _ = testMarshalErr(&v259v1, h, t, "-")
-	v259v2 = nil
-	testUnmarshalErr(&v259v2, bs259, h, t, "-")
-	testDeepEqualErr(v259v1, v259v2, t, "-")
-
-	v260v1 := map[int64]uintptr{10: 10}
-	bs260, _ := testMarshalErr(v260v1, h, t, "-")
-	v260v2 := make(map[int64]uintptr)
-	testUnmarshalErr(v260v2, bs260, h, t, "-")
-	testDeepEqualErr(v260v1, v260v2, t, "-")
-	bs260, _ = testMarshalErr(&v260v1, h, t, "-")
-	v260v2 = nil
-	testUnmarshalErr(&v260v2, bs260, h, t, "-")
-	testDeepEqualErr(v260v1, v260v2, t, "-")
-
-	v261v1 := map[int64]int{10: 10}
-	bs261, _ := testMarshalErr(v261v1, h, t, "-")
-	v261v2 := make(map[int64]int)
-	testUnmarshalErr(v261v2, bs261, h, t, "-")
-	testDeepEqualErr(v261v1, v261v2, t, "-")
-	bs261, _ = testMarshalErr(&v261v1, h, t, "-")
-	v261v2 = nil
-	testUnmarshalErr(&v261v2, bs261, h, t, "-")
-	testDeepEqualErr(v261v1, v261v2, t, "-")
-
-	v262v1 := map[int64]int8{10: 10}
-	bs262, _ := testMarshalErr(v262v1, h, t, "-")
-	v262v2 := make(map[int64]int8)
-	testUnmarshalErr(v262v2, bs262, h, t, "-")
-	testDeepEqualErr(v262v1, v262v2, t, "-")
-	bs262, _ = testMarshalErr(&v262v1, h, t, "-")
-	v262v2 = nil
-	testUnmarshalErr(&v262v2, bs262, h, t, "-")
-	testDeepEqualErr(v262v1, v262v2, t, "-")
-
-	v263v1 := map[int64]int16{10: 10}
-	bs263, _ := testMarshalErr(v263v1, h, t, "-")
-	v263v2 := make(map[int64]int16)
-	testUnmarshalErr(v263v2, bs263, h, t, "-")
-	testDeepEqualErr(v263v1, v263v2, t, "-")
-	bs263, _ = testMarshalErr(&v263v1, h, t, "-")
-	v263v2 = nil
-	testUnmarshalErr(&v263v2, bs263, h, t, "-")
-	testDeepEqualErr(v263v1, v263v2, t, "-")
-
-	v264v1 := map[int64]int32{10: 10}
-	bs264, _ := testMarshalErr(v264v1, h, t, "-")
-	v264v2 := make(map[int64]int32)
-	testUnmarshalErr(v264v2, bs264, h, t, "-")
-	testDeepEqualErr(v264v1, v264v2, t, "-")
-	bs264, _ = testMarshalErr(&v264v1, h, t, "-")
-	v264v2 = nil
-	testUnmarshalErr(&v264v2, bs264, h, t, "-")
-	testDeepEqualErr(v264v1, v264v2, t, "-")
-
-	v265v1 := map[int64]int64{10: 10}
-	bs265, _ := testMarshalErr(v265v1, h, t, "-")
-	v265v2 := make(map[int64]int64)
-	testUnmarshalErr(v265v2, bs265, h, t, "-")
-	testDeepEqualErr(v265v1, v265v2, t, "-")
-	bs265, _ = testMarshalErr(&v265v1, h, t, "-")
-	v265v2 = nil
-	testUnmarshalErr(&v265v2, bs265, h, t, "-")
-	testDeepEqualErr(v265v1, v265v2, t, "-")
-
-	v266v1 := map[int64]float32{10: 10.1}
-	bs266, _ := testMarshalErr(v266v1, h, t, "-")
-	v266v2 := make(map[int64]float32)
-	testUnmarshalErr(v266v2, bs266, h, t, "-")
-	testDeepEqualErr(v266v1, v266v2, t, "-")
-	bs266, _ = testMarshalErr(&v266v1, h, t, "-")
-	v266v2 = nil
-	testUnmarshalErr(&v266v2, bs266, h, t, "-")
-	testDeepEqualErr(v266v1, v266v2, t, "-")
-
-	v267v1 := map[int64]float64{10: 10.1}
-	bs267, _ := testMarshalErr(v267v1, h, t, "-")
-	v267v2 := make(map[int64]float64)
-	testUnmarshalErr(v267v2, bs267, h, t, "-")
-	testDeepEqualErr(v267v1, v267v2, t, "-")
-	bs267, _ = testMarshalErr(&v267v1, h, t, "-")
-	v267v2 = nil
-	testUnmarshalErr(&v267v2, bs267, h, t, "-")
-	testDeepEqualErr(v267v1, v267v2, t, "-")
-
-	v268v1 := map[int64]bool{10: true}
-	bs268, _ := testMarshalErr(v268v1, h, t, "-")
-	v268v2 := make(map[int64]bool)
-	testUnmarshalErr(v268v2, bs268, h, t, "-")
-	testDeepEqualErr(v268v1, v268v2, t, "-")
-	bs268, _ = testMarshalErr(&v268v1, h, t, "-")
-	v268v2 = nil
-	testUnmarshalErr(&v268v2, bs268, h, t, "-")
-	testDeepEqualErr(v268v1, v268v2, t, "-")
-
-	v271v1 := map[bool]interface{}{true: "string-is-an-interface"}
-	bs271, _ := testMarshalErr(v271v1, h, t, "-")
-	v271v2 := make(map[bool]interface{})
-	testUnmarshalErr(v271v2, bs271, h, t, "-")
-	testDeepEqualErr(v271v1, v271v2, t, "-")
-	bs271, _ = testMarshalErr(&v271v1, h, t, "-")
-	v271v2 = nil
-	testUnmarshalErr(&v271v2, bs271, h, t, "-")
-	testDeepEqualErr(v271v1, v271v2, t, "-")
-
-	v272v1 := map[bool]string{true: "some-string"}
-	bs272, _ := testMarshalErr(v272v1, h, t, "-")
-	v272v2 := make(map[bool]string)
-	testUnmarshalErr(v272v2, bs272, h, t, "-")
-	testDeepEqualErr(v272v1, v272v2, t, "-")
-	bs272, _ = testMarshalErr(&v272v1, h, t, "-")
-	v272v2 = nil
-	testUnmarshalErr(&v272v2, bs272, h, t, "-")
-	testDeepEqualErr(v272v1, v272v2, t, "-")
-
-	v273v1 := map[bool]uint{true: 10}
-	bs273, _ := testMarshalErr(v273v1, h, t, "-")
-	v273v2 := make(map[bool]uint)
-	testUnmarshalErr(v273v2, bs273, h, t, "-")
-	testDeepEqualErr(v273v1, v273v2, t, "-")
-	bs273, _ = testMarshalErr(&v273v1, h, t, "-")
-	v273v2 = nil
-	testUnmarshalErr(&v273v2, bs273, h, t, "-")
-	testDeepEqualErr(v273v1, v273v2, t, "-")
-
-	v274v1 := map[bool]uint8{true: 10}
-	bs274, _ := testMarshalErr(v274v1, h, t, "-")
-	v274v2 := make(map[bool]uint8)
-	testUnmarshalErr(v274v2, bs274, h, t, "-")
-	testDeepEqualErr(v274v1, v274v2, t, "-")
-	bs274, _ = testMarshalErr(&v274v1, h, t, "-")
-	v274v2 = nil
-	testUnmarshalErr(&v274v2, bs274, h, t, "-")
-	testDeepEqualErr(v274v1, v274v2, t, "-")
-
-	v275v1 := map[bool]uint16{true: 10}
-	bs275, _ := testMarshalErr(v275v1, h, t, "-")
-	v275v2 := make(map[bool]uint16)
-	testUnmarshalErr(v275v2, bs275, h, t, "-")
-	testDeepEqualErr(v275v1, v275v2, t, "-")
-	bs275, _ = testMarshalErr(&v275v1, h, t, "-")
-	v275v2 = nil
-	testUnmarshalErr(&v275v2, bs275, h, t, "-")
-	testDeepEqualErr(v275v1, v275v2, t, "-")
-
-	v276v1 := map[bool]uint32{true: 10}
-	bs276, _ := testMarshalErr(v276v1, h, t, "-")
-	v276v2 := make(map[bool]uint32)
-	testUnmarshalErr(v276v2, bs276, h, t, "-")
-	testDeepEqualErr(v276v1, v276v2, t, "-")
-	bs276, _ = testMarshalErr(&v276v1, h, t, "-")
-	v276v2 = nil
-	testUnmarshalErr(&v276v2, bs276, h, t, "-")
-	testDeepEqualErr(v276v1, v276v2, t, "-")
-
-	v277v1 := map[bool]uint64{true: 10}
-	bs277, _ := testMarshalErr(v277v1, h, t, "-")
-	v277v2 := make(map[bool]uint64)
-	testUnmarshalErr(v277v2, bs277, h, t, "-")
-	testDeepEqualErr(v277v1, v277v2, t, "-")
-	bs277, _ = testMarshalErr(&v277v1, h, t, "-")
-	v277v2 = nil
-	testUnmarshalErr(&v277v2, bs277, h, t, "-")
-	testDeepEqualErr(v277v1, v277v2, t, "-")
-
-	v278v1 := map[bool]uintptr{true: 10}
-	bs278, _ := testMarshalErr(v278v1, h, t, "-")
-	v278v2 := make(map[bool]uintptr)
-	testUnmarshalErr(v278v2, bs278, h, t, "-")
-	testDeepEqualErr(v278v1, v278v2, t, "-")
-	bs278, _ = testMarshalErr(&v278v1, h, t, "-")
-	v278v2 = nil
-	testUnmarshalErr(&v278v2, bs278, h, t, "-")
-	testDeepEqualErr(v278v1, v278v2, t, "-")
-
-	v279v1 := map[bool]int{true: 10}
-	bs279, _ := testMarshalErr(v279v1, h, t, "-")
-	v279v2 := make(map[bool]int)
-	testUnmarshalErr(v279v2, bs279, h, t, "-")
-	testDeepEqualErr(v279v1, v279v2, t, "-")
-	bs279, _ = testMarshalErr(&v279v1, h, t, "-")
-	v279v2 = nil
-	testUnmarshalErr(&v279v2, bs279, h, t, "-")
-	testDeepEqualErr(v279v1, v279v2, t, "-")
-
-	v280v1 := map[bool]int8{true: 10}
-	bs280, _ := testMarshalErr(v280v1, h, t, "-")
-	v280v2 := make(map[bool]int8)
-	testUnmarshalErr(v280v2, bs280, h, t, "-")
-	testDeepEqualErr(v280v1, v280v2, t, "-")
-	bs280, _ = testMarshalErr(&v280v1, h, t, "-")
-	v280v2 = nil
-	testUnmarshalErr(&v280v2, bs280, h, t, "-")
-	testDeepEqualErr(v280v1, v280v2, t, "-")
-
-	v281v1 := map[bool]int16{true: 10}
-	bs281, _ := testMarshalErr(v281v1, h, t, "-")
-	v281v2 := make(map[bool]int16)
-	testUnmarshalErr(v281v2, bs281, h, t, "-")
-	testDeepEqualErr(v281v1, v281v2, t, "-")
-	bs281, _ = testMarshalErr(&v281v1, h, t, "-")
-	v281v2 = nil
-	testUnmarshalErr(&v281v2, bs281, h, t, "-")
-	testDeepEqualErr(v281v1, v281v2, t, "-")
-
-	v282v1 := map[bool]int32{true: 10}
-	bs282, _ := testMarshalErr(v282v1, h, t, "-")
-	v282v2 := make(map[bool]int32)
-	testUnmarshalErr(v282v2, bs282, h, t, "-")
-	testDeepEqualErr(v282v1, v282v2, t, "-")
-	bs282, _ = testMarshalErr(&v282v1, h, t, "-")
-	v282v2 = nil
-	testUnmarshalErr(&v282v2, bs282, h, t, "-")
-	testDeepEqualErr(v282v1, v282v2, t, "-")
-
-	v283v1 := map[bool]int64{true: 10}
-	bs283, _ := testMarshalErr(v283v1, h, t, "-")
-	v283v2 := make(map[bool]int64)
-	testUnmarshalErr(v283v2, bs283, h, t, "-")
-	testDeepEqualErr(v283v1, v283v2, t, "-")
-	bs283, _ = testMarshalErr(&v283v1, h, t, "-")
-	v283v2 = nil
-	testUnmarshalErr(&v283v2, bs283, h, t, "-")
-	testDeepEqualErr(v283v1, v283v2, t, "-")
-
-	v284v1 := map[bool]float32{true: 10.1}
-	bs284, _ := testMarshalErr(v284v1, h, t, "-")
-	v284v2 := make(map[bool]float32)
-	testUnmarshalErr(v284v2, bs284, h, t, "-")
-	testDeepEqualErr(v284v1, v284v2, t, "-")
-	bs284, _ = testMarshalErr(&v284v1, h, t, "-")
-	v284v2 = nil
-	testUnmarshalErr(&v284v2, bs284, h, t, "-")
-	testDeepEqualErr(v284v1, v284v2, t, "-")
-
-	v285v1 := map[bool]float64{true: 10.1}
-	bs285, _ := testMarshalErr(v285v1, h, t, "-")
-	v285v2 := make(map[bool]float64)
-	testUnmarshalErr(v285v2, bs285, h, t, "-")
-	testDeepEqualErr(v285v1, v285v2, t, "-")
-	bs285, _ = testMarshalErr(&v285v1, h, t, "-")
-	v285v2 = nil
-	testUnmarshalErr(&v285v2, bs285, h, t, "-")
-	testDeepEqualErr(v285v1, v285v2, t, "-")
-
-	v286v1 := map[bool]bool{true: true}
-	bs286, _ := testMarshalErr(v286v1, h, t, "-")
-	v286v2 := make(map[bool]bool)
-	testUnmarshalErr(v286v2, bs286, h, t, "-")
-	testDeepEqualErr(v286v1, v286v2, t, "-")
-	bs286, _ = testMarshalErr(&v286v1, h, t, "-")
-	v286v2 = nil
-	testUnmarshalErr(&v286v2, bs286, h, t, "-")
-	testDeepEqualErr(v286v1, v286v2, t, "-")
+	for _, v := range []map[interface{}]interface{}{nil, map[interface{}]interface{}{}, map[interface{}]interface{}{"string-is-an-interface": "string-is-an-interface"}} {
+		// fmt.Printf(">>>> running mammoth map v2: %v\n", v)
+		var v2v1, v2v2 map[interface{}]interface{}
+		v2v1 = v
+		bs2, _ := testMarshalErr(v2v1, h, t, "enc-map-v2")
+		if v != nil {
+			v2v2 = make(map[interface{}]interface{}, len(v))
+		}
+		testUnmarshalErr(v2v2, bs2, h, t, "dec-map-v2")
+		testDeepEqualErr(v2v1, v2v2, t, "equal-map-v2")
+		bs2, _ = testMarshalErr(&v2v1, h, t, "enc-map-v2-p")
+		v2v2 = nil
+		testUnmarshalErr(&v2v2, bs2, h, t, "dec-map-v2-p")
+		testDeepEqualErr(v2v1, v2v2, t, "equal-map-v2-p")
+	}
+
+	for _, v := range []map[interface{}]string{nil, map[interface{}]string{}, map[interface{}]string{"string-is-an-interface": "some-string"}} {
+		// fmt.Printf(">>>> running mammoth map v3: %v\n", v)
+		var v3v1, v3v2 map[interface{}]string
+		v3v1 = v
+		bs3, _ := testMarshalErr(v3v1, h, t, "enc-map-v3")
+		if v != nil {
+			v3v2 = make(map[interface{}]string, len(v))
+		}
+		testUnmarshalErr(v3v2, bs3, h, t, "dec-map-v3")
+		testDeepEqualErr(v3v1, v3v2, t, "equal-map-v3")
+		bs3, _ = testMarshalErr(&v3v1, h, t, "enc-map-v3-p")
+		v3v2 = nil
+		testUnmarshalErr(&v3v2, bs3, h, t, "dec-map-v3-p")
+		testDeepEqualErr(v3v1, v3v2, t, "equal-map-v3-p")
+	}
+
+	for _, v := range []map[interface{}]uint{nil, map[interface{}]uint{}, map[interface{}]uint{"string-is-an-interface": 10}} {
+		// fmt.Printf(">>>> running mammoth map v4: %v\n", v)
+		var v4v1, v4v2 map[interface{}]uint
+		v4v1 = v
+		bs4, _ := testMarshalErr(v4v1, h, t, "enc-map-v4")
+		if v != nil {
+			v4v2 = make(map[interface{}]uint, len(v))
+		}
+		testUnmarshalErr(v4v2, bs4, h, t, "dec-map-v4")
+		testDeepEqualErr(v4v1, v4v2, t, "equal-map-v4")
+		bs4, _ = testMarshalErr(&v4v1, h, t, "enc-map-v4-p")
+		v4v2 = nil
+		testUnmarshalErr(&v4v2, bs4, h, t, "dec-map-v4-p")
+		testDeepEqualErr(v4v1, v4v2, t, "equal-map-v4-p")
+	}
+
+	for _, v := range []map[interface{}]uint8{nil, map[interface{}]uint8{}, map[interface{}]uint8{"string-is-an-interface": 10}} {
+		// fmt.Printf(">>>> running mammoth map v5: %v\n", v)
+		var v5v1, v5v2 map[interface{}]uint8
+		v5v1 = v
+		bs5, _ := testMarshalErr(v5v1, h, t, "enc-map-v5")
+		if v != nil {
+			v5v2 = make(map[interface{}]uint8, len(v))
+		}
+		testUnmarshalErr(v5v2, bs5, h, t, "dec-map-v5")
+		testDeepEqualErr(v5v1, v5v2, t, "equal-map-v5")
+		bs5, _ = testMarshalErr(&v5v1, h, t, "enc-map-v5-p")
+		v5v2 = nil
+		testUnmarshalErr(&v5v2, bs5, h, t, "dec-map-v5-p")
+		testDeepEqualErr(v5v1, v5v2, t, "equal-map-v5-p")
+	}
+
+	for _, v := range []map[interface{}]uint16{nil, map[interface{}]uint16{}, map[interface{}]uint16{"string-is-an-interface": 10}} {
+		// fmt.Printf(">>>> running mammoth map v6: %v\n", v)
+		var v6v1, v6v2 map[interface{}]uint16
+		v6v1 = v
+		bs6, _ := testMarshalErr(v6v1, h, t, "enc-map-v6")
+		if v != nil {
+			v6v2 = make(map[interface{}]uint16, len(v))
+		}
+		testUnmarshalErr(v6v2, bs6, h, t, "dec-map-v6")
+		testDeepEqualErr(v6v1, v6v2, t, "equal-map-v6")
+		bs6, _ = testMarshalErr(&v6v1, h, t, "enc-map-v6-p")
+		v6v2 = nil
+		testUnmarshalErr(&v6v2, bs6, h, t, "dec-map-v6-p")
+		testDeepEqualErr(v6v1, v6v2, t, "equal-map-v6-p")
+	}
+
+	for _, v := range []map[interface{}]uint32{nil, map[interface{}]uint32{}, map[interface{}]uint32{"string-is-an-interface": 10}} {
+		// fmt.Printf(">>>> running mammoth map v7: %v\n", v)
+		var v7v1, v7v2 map[interface{}]uint32
+		v7v1 = v
+		bs7, _ := testMarshalErr(v7v1, h, t, "enc-map-v7")
+		if v != nil {
+			v7v2 = make(map[interface{}]uint32, len(v))
+		}
+		testUnmarshalErr(v7v2, bs7, h, t, "dec-map-v7")
+		testDeepEqualErr(v7v1, v7v2, t, "equal-map-v7")
+		bs7, _ = testMarshalErr(&v7v1, h, t, "enc-map-v7-p")
+		v7v2 = nil
+		testUnmarshalErr(&v7v2, bs7, h, t, "dec-map-v7-p")
+		testDeepEqualErr(v7v1, v7v2, t, "equal-map-v7-p")
+	}
+
+	for _, v := range []map[interface{}]uint64{nil, map[interface{}]uint64{}, map[interface{}]uint64{"string-is-an-interface": 10}} {
+		// fmt.Printf(">>>> running mammoth map v8: %v\n", v)
+		var v8v1, v8v2 map[interface{}]uint64
+		v8v1 = v
+		bs8, _ := testMarshalErr(v8v1, h, t, "enc-map-v8")
+		if v != nil {
+			v8v2 = make(map[interface{}]uint64, len(v))
+		}
+		testUnmarshalErr(v8v2, bs8, h, t, "dec-map-v8")
+		testDeepEqualErr(v8v1, v8v2, t, "equal-map-v8")
+		bs8, _ = testMarshalErr(&v8v1, h, t, "enc-map-v8-p")
+		v8v2 = nil
+		testUnmarshalErr(&v8v2, bs8, h, t, "dec-map-v8-p")
+		testDeepEqualErr(v8v1, v8v2, t, "equal-map-v8-p")
+	}
+
+	for _, v := range []map[interface{}]uintptr{nil, map[interface{}]uintptr{}, map[interface{}]uintptr{"string-is-an-interface": 10}} {
+		// fmt.Printf(">>>> running mammoth map v9: %v\n", v)
+		var v9v1, v9v2 map[interface{}]uintptr
+		v9v1 = v
+		bs9, _ := testMarshalErr(v9v1, h, t, "enc-map-v9")
+		if v != nil {
+			v9v2 = make(map[interface{}]uintptr, len(v))
+		}
+		testUnmarshalErr(v9v2, bs9, h, t, "dec-map-v9")
+		testDeepEqualErr(v9v1, v9v2, t, "equal-map-v9")
+		bs9, _ = testMarshalErr(&v9v1, h, t, "enc-map-v9-p")
+		v9v2 = nil
+		testUnmarshalErr(&v9v2, bs9, h, t, "dec-map-v9-p")
+		testDeepEqualErr(v9v1, v9v2, t, "equal-map-v9-p")
+	}
+
+	for _, v := range []map[interface{}]int{nil, map[interface{}]int{}, map[interface{}]int{"string-is-an-interface": 10}} {
+		// fmt.Printf(">>>> running mammoth map v10: %v\n", v)
+		var v10v1, v10v2 map[interface{}]int
+		v10v1 = v
+		bs10, _ := testMarshalErr(v10v1, h, t, "enc-map-v10")
+		if v != nil {
+			v10v2 = make(map[interface{}]int, len(v))
+		}
+		testUnmarshalErr(v10v2, bs10, h, t, "dec-map-v10")
+		testDeepEqualErr(v10v1, v10v2, t, "equal-map-v10")
+		bs10, _ = testMarshalErr(&v10v1, h, t, "enc-map-v10-p")
+		v10v2 = nil
+		testUnmarshalErr(&v10v2, bs10, h, t, "dec-map-v10-p")
+		testDeepEqualErr(v10v1, v10v2, t, "equal-map-v10-p")
+	}
+
+	for _, v := range []map[interface{}]int8{nil, map[interface{}]int8{}, map[interface{}]int8{"string-is-an-interface": 10}} {
+		// fmt.Printf(">>>> running mammoth map v11: %v\n", v)
+		var v11v1, v11v2 map[interface{}]int8
+		v11v1 = v
+		bs11, _ := testMarshalErr(v11v1, h, t, "enc-map-v11")
+		if v != nil {
+			v11v2 = make(map[interface{}]int8, len(v))
+		}
+		testUnmarshalErr(v11v2, bs11, h, t, "dec-map-v11")
+		testDeepEqualErr(v11v1, v11v2, t, "equal-map-v11")
+		bs11, _ = testMarshalErr(&v11v1, h, t, "enc-map-v11-p")
+		v11v2 = nil
+		testUnmarshalErr(&v11v2, bs11, h, t, "dec-map-v11-p")
+		testDeepEqualErr(v11v1, v11v2, t, "equal-map-v11-p")
+	}
+
+	for _, v := range []map[interface{}]int16{nil, map[interface{}]int16{}, map[interface{}]int16{"string-is-an-interface": 10}} {
+		// fmt.Printf(">>>> running mammoth map v12: %v\n", v)
+		var v12v1, v12v2 map[interface{}]int16
+		v12v1 = v
+		bs12, _ := testMarshalErr(v12v1, h, t, "enc-map-v12")
+		if v != nil {
+			v12v2 = make(map[interface{}]int16, len(v))
+		}
+		testUnmarshalErr(v12v2, bs12, h, t, "dec-map-v12")
+		testDeepEqualErr(v12v1, v12v2, t, "equal-map-v12")
+		bs12, _ = testMarshalErr(&v12v1, h, t, "enc-map-v12-p")
+		v12v2 = nil
+		testUnmarshalErr(&v12v2, bs12, h, t, "dec-map-v12-p")
+		testDeepEqualErr(v12v1, v12v2, t, "equal-map-v12-p")
+	}
+
+	for _, v := range []map[interface{}]int32{nil, map[interface{}]int32{}, map[interface{}]int32{"string-is-an-interface": 10}} {
+		// fmt.Printf(">>>> running mammoth map v13: %v\n", v)
+		var v13v1, v13v2 map[interface{}]int32
+		v13v1 = v
+		bs13, _ := testMarshalErr(v13v1, h, t, "enc-map-v13")
+		if v != nil {
+			v13v2 = make(map[interface{}]int32, len(v))
+		}
+		testUnmarshalErr(v13v2, bs13, h, t, "dec-map-v13")
+		testDeepEqualErr(v13v1, v13v2, t, "equal-map-v13")
+		bs13, _ = testMarshalErr(&v13v1, h, t, "enc-map-v13-p")
+		v13v2 = nil
+		testUnmarshalErr(&v13v2, bs13, h, t, "dec-map-v13-p")
+		testDeepEqualErr(v13v1, v13v2, t, "equal-map-v13-p")
+	}
+
+	for _, v := range []map[interface{}]int64{nil, map[interface{}]int64{}, map[interface{}]int64{"string-is-an-interface": 10}} {
+		// fmt.Printf(">>>> running mammoth map v14: %v\n", v)
+		var v14v1, v14v2 map[interface{}]int64
+		v14v1 = v
+		bs14, _ := testMarshalErr(v14v1, h, t, "enc-map-v14")
+		if v != nil {
+			v14v2 = make(map[interface{}]int64, len(v))
+		}
+		testUnmarshalErr(v14v2, bs14, h, t, "dec-map-v14")
+		testDeepEqualErr(v14v1, v14v2, t, "equal-map-v14")
+		bs14, _ = testMarshalErr(&v14v1, h, t, "enc-map-v14-p")
+		v14v2 = nil
+		testUnmarshalErr(&v14v2, bs14, h, t, "dec-map-v14-p")
+		testDeepEqualErr(v14v1, v14v2, t, "equal-map-v14-p")
+	}
+
+	for _, v := range []map[interface{}]float32{nil, map[interface{}]float32{}, map[interface{}]float32{"string-is-an-interface": 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v15: %v\n", v)
+		var v15v1, v15v2 map[interface{}]float32
+		v15v1 = v
+		bs15, _ := testMarshalErr(v15v1, h, t, "enc-map-v15")
+		if v != nil {
+			v15v2 = make(map[interface{}]float32, len(v))
+		}
+		testUnmarshalErr(v15v2, bs15, h, t, "dec-map-v15")
+		testDeepEqualErr(v15v1, v15v2, t, "equal-map-v15")
+		bs15, _ = testMarshalErr(&v15v1, h, t, "enc-map-v15-p")
+		v15v2 = nil
+		testUnmarshalErr(&v15v2, bs15, h, t, "dec-map-v15-p")
+		testDeepEqualErr(v15v1, v15v2, t, "equal-map-v15-p")
+	}
+
+	for _, v := range []map[interface{}]float64{nil, map[interface{}]float64{}, map[interface{}]float64{"string-is-an-interface": 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v16: %v\n", v)
+		var v16v1, v16v2 map[interface{}]float64
+		v16v1 = v
+		bs16, _ := testMarshalErr(v16v1, h, t, "enc-map-v16")
+		if v != nil {
+			v16v2 = make(map[interface{}]float64, len(v))
+		}
+		testUnmarshalErr(v16v2, bs16, h, t, "dec-map-v16")
+		testDeepEqualErr(v16v1, v16v2, t, "equal-map-v16")
+		bs16, _ = testMarshalErr(&v16v1, h, t, "enc-map-v16-p")
+		v16v2 = nil
+		testUnmarshalErr(&v16v2, bs16, h, t, "dec-map-v16-p")
+		testDeepEqualErr(v16v1, v16v2, t, "equal-map-v16-p")
+	}
+
+	for _, v := range []map[interface{}]bool{nil, map[interface{}]bool{}, map[interface{}]bool{"string-is-an-interface": true}} {
+		// fmt.Printf(">>>> running mammoth map v17: %v\n", v)
+		var v17v1, v17v2 map[interface{}]bool
+		v17v1 = v
+		bs17, _ := testMarshalErr(v17v1, h, t, "enc-map-v17")
+		if v != nil {
+			v17v2 = make(map[interface{}]bool, len(v))
+		}
+		testUnmarshalErr(v17v2, bs17, h, t, "dec-map-v17")
+		testDeepEqualErr(v17v1, v17v2, t, "equal-map-v17")
+		bs17, _ = testMarshalErr(&v17v1, h, t, "enc-map-v17-p")
+		v17v2 = nil
+		testUnmarshalErr(&v17v2, bs17, h, t, "dec-map-v17-p")
+		testDeepEqualErr(v17v1, v17v2, t, "equal-map-v17-p")
+	}
+
+	for _, v := range []map[string]interface{}{nil, map[string]interface{}{}, map[string]interface{}{"some-string": "string-is-an-interface"}} {
+		// fmt.Printf(">>>> running mammoth map v20: %v\n", v)
+		var v20v1, v20v2 map[string]interface{}
+		v20v1 = v
+		bs20, _ := testMarshalErr(v20v1, h, t, "enc-map-v20")
+		if v != nil {
+			v20v2 = make(map[string]interface{}, len(v))
+		}
+		testUnmarshalErr(v20v2, bs20, h, t, "dec-map-v20")
+		testDeepEqualErr(v20v1, v20v2, t, "equal-map-v20")
+		bs20, _ = testMarshalErr(&v20v1, h, t, "enc-map-v20-p")
+		v20v2 = nil
+		testUnmarshalErr(&v20v2, bs20, h, t, "dec-map-v20-p")
+		testDeepEqualErr(v20v1, v20v2, t, "equal-map-v20-p")
+	}
+
+	for _, v := range []map[string]string{nil, map[string]string{}, map[string]string{"some-string": "some-string"}} {
+		// fmt.Printf(">>>> running mammoth map v21: %v\n", v)
+		var v21v1, v21v2 map[string]string
+		v21v1 = v
+		bs21, _ := testMarshalErr(v21v1, h, t, "enc-map-v21")
+		if v != nil {
+			v21v2 = make(map[string]string, len(v))
+		}
+		testUnmarshalErr(v21v2, bs21, h, t, "dec-map-v21")
+		testDeepEqualErr(v21v1, v21v2, t, "equal-map-v21")
+		bs21, _ = testMarshalErr(&v21v1, h, t, "enc-map-v21-p")
+		v21v2 = nil
+		testUnmarshalErr(&v21v2, bs21, h, t, "dec-map-v21-p")
+		testDeepEqualErr(v21v1, v21v2, t, "equal-map-v21-p")
+	}
+
+	for _, v := range []map[string]uint{nil, map[string]uint{}, map[string]uint{"some-string": 10}} {
+		// fmt.Printf(">>>> running mammoth map v22: %v\n", v)
+		var v22v1, v22v2 map[string]uint
+		v22v1 = v
+		bs22, _ := testMarshalErr(v22v1, h, t, "enc-map-v22")
+		if v != nil {
+			v22v2 = make(map[string]uint, len(v))
+		}
+		testUnmarshalErr(v22v2, bs22, h, t, "dec-map-v22")
+		testDeepEqualErr(v22v1, v22v2, t, "equal-map-v22")
+		bs22, _ = testMarshalErr(&v22v1, h, t, "enc-map-v22-p")
+		v22v2 = nil
+		testUnmarshalErr(&v22v2, bs22, h, t, "dec-map-v22-p")
+		testDeepEqualErr(v22v1, v22v2, t, "equal-map-v22-p")
+	}
+
+	for _, v := range []map[string]uint8{nil, map[string]uint8{}, map[string]uint8{"some-string": 10}} {
+		// fmt.Printf(">>>> running mammoth map v23: %v\n", v)
+		var v23v1, v23v2 map[string]uint8
+		v23v1 = v
+		bs23, _ := testMarshalErr(v23v1, h, t, "enc-map-v23")
+		if v != nil {
+			v23v2 = make(map[string]uint8, len(v))
+		}
+		testUnmarshalErr(v23v2, bs23, h, t, "dec-map-v23")
+		testDeepEqualErr(v23v1, v23v2, t, "equal-map-v23")
+		bs23, _ = testMarshalErr(&v23v1, h, t, "enc-map-v23-p")
+		v23v2 = nil
+		testUnmarshalErr(&v23v2, bs23, h, t, "dec-map-v23-p")
+		testDeepEqualErr(v23v1, v23v2, t, "equal-map-v23-p")
+	}
+
+	for _, v := range []map[string]uint16{nil, map[string]uint16{}, map[string]uint16{"some-string": 10}} {
+		// fmt.Printf(">>>> running mammoth map v24: %v\n", v)
+		var v24v1, v24v2 map[string]uint16
+		v24v1 = v
+		bs24, _ := testMarshalErr(v24v1, h, t, "enc-map-v24")
+		if v != nil {
+			v24v2 = make(map[string]uint16, len(v))
+		}
+		testUnmarshalErr(v24v2, bs24, h, t, "dec-map-v24")
+		testDeepEqualErr(v24v1, v24v2, t, "equal-map-v24")
+		bs24, _ = testMarshalErr(&v24v1, h, t, "enc-map-v24-p")
+		v24v2 = nil
+		testUnmarshalErr(&v24v2, bs24, h, t, "dec-map-v24-p")
+		testDeepEqualErr(v24v1, v24v2, t, "equal-map-v24-p")
+	}
+
+	for _, v := range []map[string]uint32{nil, map[string]uint32{}, map[string]uint32{"some-string": 10}} {
+		// fmt.Printf(">>>> running mammoth map v25: %v\n", v)
+		var v25v1, v25v2 map[string]uint32
+		v25v1 = v
+		bs25, _ := testMarshalErr(v25v1, h, t, "enc-map-v25")
+		if v != nil {
+			v25v2 = make(map[string]uint32, len(v))
+		}
+		testUnmarshalErr(v25v2, bs25, h, t, "dec-map-v25")
+		testDeepEqualErr(v25v1, v25v2, t, "equal-map-v25")
+		bs25, _ = testMarshalErr(&v25v1, h, t, "enc-map-v25-p")
+		v25v2 = nil
+		testUnmarshalErr(&v25v2, bs25, h, t, "dec-map-v25-p")
+		testDeepEqualErr(v25v1, v25v2, t, "equal-map-v25-p")
+	}
+
+	for _, v := range []map[string]uint64{nil, map[string]uint64{}, map[string]uint64{"some-string": 10}} {
+		// fmt.Printf(">>>> running mammoth map v26: %v\n", v)
+		var v26v1, v26v2 map[string]uint64
+		v26v1 = v
+		bs26, _ := testMarshalErr(v26v1, h, t, "enc-map-v26")
+		if v != nil {
+			v26v2 = make(map[string]uint64, len(v))
+		}
+		testUnmarshalErr(v26v2, bs26, h, t, "dec-map-v26")
+		testDeepEqualErr(v26v1, v26v2, t, "equal-map-v26")
+		bs26, _ = testMarshalErr(&v26v1, h, t, "enc-map-v26-p")
+		v26v2 = nil
+		testUnmarshalErr(&v26v2, bs26, h, t, "dec-map-v26-p")
+		testDeepEqualErr(v26v1, v26v2, t, "equal-map-v26-p")
+	}
+
+	for _, v := range []map[string]uintptr{nil, map[string]uintptr{}, map[string]uintptr{"some-string": 10}} {
+		// fmt.Printf(">>>> running mammoth map v27: %v\n", v)
+		var v27v1, v27v2 map[string]uintptr
+		v27v1 = v
+		bs27, _ := testMarshalErr(v27v1, h, t, "enc-map-v27")
+		if v != nil {
+			v27v2 = make(map[string]uintptr, len(v))
+		}
+		testUnmarshalErr(v27v2, bs27, h, t, "dec-map-v27")
+		testDeepEqualErr(v27v1, v27v2, t, "equal-map-v27")
+		bs27, _ = testMarshalErr(&v27v1, h, t, "enc-map-v27-p")
+		v27v2 = nil
+		testUnmarshalErr(&v27v2, bs27, h, t, "dec-map-v27-p")
+		testDeepEqualErr(v27v1, v27v2, t, "equal-map-v27-p")
+	}
+
+	for _, v := range []map[string]int{nil, map[string]int{}, map[string]int{"some-string": 10}} {
+		// fmt.Printf(">>>> running mammoth map v28: %v\n", v)
+		var v28v1, v28v2 map[string]int
+		v28v1 = v
+		bs28, _ := testMarshalErr(v28v1, h, t, "enc-map-v28")
+		if v != nil {
+			v28v2 = make(map[string]int, len(v))
+		}
+		testUnmarshalErr(v28v2, bs28, h, t, "dec-map-v28")
+		testDeepEqualErr(v28v1, v28v2, t, "equal-map-v28")
+		bs28, _ = testMarshalErr(&v28v1, h, t, "enc-map-v28-p")
+		v28v2 = nil
+		testUnmarshalErr(&v28v2, bs28, h, t, "dec-map-v28-p")
+		testDeepEqualErr(v28v1, v28v2, t, "equal-map-v28-p")
+	}
+
+	for _, v := range []map[string]int8{nil, map[string]int8{}, map[string]int8{"some-string": 10}} {
+		// fmt.Printf(">>>> running mammoth map v29: %v\n", v)
+		var v29v1, v29v2 map[string]int8
+		v29v1 = v
+		bs29, _ := testMarshalErr(v29v1, h, t, "enc-map-v29")
+		if v != nil {
+			v29v2 = make(map[string]int8, len(v))
+		}
+		testUnmarshalErr(v29v2, bs29, h, t, "dec-map-v29")
+		testDeepEqualErr(v29v1, v29v2, t, "equal-map-v29")
+		bs29, _ = testMarshalErr(&v29v1, h, t, "enc-map-v29-p")
+		v29v2 = nil
+		testUnmarshalErr(&v29v2, bs29, h, t, "dec-map-v29-p")
+		testDeepEqualErr(v29v1, v29v2, t, "equal-map-v29-p")
+	}
+
+	for _, v := range []map[string]int16{nil, map[string]int16{}, map[string]int16{"some-string": 10}} {
+		// fmt.Printf(">>>> running mammoth map v30: %v\n", v)
+		var v30v1, v30v2 map[string]int16
+		v30v1 = v
+		bs30, _ := testMarshalErr(v30v1, h, t, "enc-map-v30")
+		if v != nil {
+			v30v2 = make(map[string]int16, len(v))
+		}
+		testUnmarshalErr(v30v2, bs30, h, t, "dec-map-v30")
+		testDeepEqualErr(v30v1, v30v2, t, "equal-map-v30")
+		bs30, _ = testMarshalErr(&v30v1, h, t, "enc-map-v30-p")
+		v30v2 = nil
+		testUnmarshalErr(&v30v2, bs30, h, t, "dec-map-v30-p")
+		testDeepEqualErr(v30v1, v30v2, t, "equal-map-v30-p")
+	}
+
+	for _, v := range []map[string]int32{nil, map[string]int32{}, map[string]int32{"some-string": 10}} {
+		// fmt.Printf(">>>> running mammoth map v31: %v\n", v)
+		var v31v1, v31v2 map[string]int32
+		v31v1 = v
+		bs31, _ := testMarshalErr(v31v1, h, t, "enc-map-v31")
+		if v != nil {
+			v31v2 = make(map[string]int32, len(v))
+		}
+		testUnmarshalErr(v31v2, bs31, h, t, "dec-map-v31")
+		testDeepEqualErr(v31v1, v31v2, t, "equal-map-v31")
+		bs31, _ = testMarshalErr(&v31v1, h, t, "enc-map-v31-p")
+		v31v2 = nil
+		testUnmarshalErr(&v31v2, bs31, h, t, "dec-map-v31-p")
+		testDeepEqualErr(v31v1, v31v2, t, "equal-map-v31-p")
+	}
+
+	for _, v := range []map[string]int64{nil, map[string]int64{}, map[string]int64{"some-string": 10}} {
+		// fmt.Printf(">>>> running mammoth map v32: %v\n", v)
+		var v32v1, v32v2 map[string]int64
+		v32v1 = v
+		bs32, _ := testMarshalErr(v32v1, h, t, "enc-map-v32")
+		if v != nil {
+			v32v2 = make(map[string]int64, len(v))
+		}
+		testUnmarshalErr(v32v2, bs32, h, t, "dec-map-v32")
+		testDeepEqualErr(v32v1, v32v2, t, "equal-map-v32")
+		bs32, _ = testMarshalErr(&v32v1, h, t, "enc-map-v32-p")
+		v32v2 = nil
+		testUnmarshalErr(&v32v2, bs32, h, t, "dec-map-v32-p")
+		testDeepEqualErr(v32v1, v32v2, t, "equal-map-v32-p")
+	}
+
+	for _, v := range []map[string]float32{nil, map[string]float32{}, map[string]float32{"some-string": 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v33: %v\n", v)
+		var v33v1, v33v2 map[string]float32
+		v33v1 = v
+		bs33, _ := testMarshalErr(v33v1, h, t, "enc-map-v33")
+		if v != nil {
+			v33v2 = make(map[string]float32, len(v))
+		}
+		testUnmarshalErr(v33v2, bs33, h, t, "dec-map-v33")
+		testDeepEqualErr(v33v1, v33v2, t, "equal-map-v33")
+		bs33, _ = testMarshalErr(&v33v1, h, t, "enc-map-v33-p")
+		v33v2 = nil
+		testUnmarshalErr(&v33v2, bs33, h, t, "dec-map-v33-p")
+		testDeepEqualErr(v33v1, v33v2, t, "equal-map-v33-p")
+	}
+
+	for _, v := range []map[string]float64{nil, map[string]float64{}, map[string]float64{"some-string": 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v34: %v\n", v)
+		var v34v1, v34v2 map[string]float64
+		v34v1 = v
+		bs34, _ := testMarshalErr(v34v1, h, t, "enc-map-v34")
+		if v != nil {
+			v34v2 = make(map[string]float64, len(v))
+		}
+		testUnmarshalErr(v34v2, bs34, h, t, "dec-map-v34")
+		testDeepEqualErr(v34v1, v34v2, t, "equal-map-v34")
+		bs34, _ = testMarshalErr(&v34v1, h, t, "enc-map-v34-p")
+		v34v2 = nil
+		testUnmarshalErr(&v34v2, bs34, h, t, "dec-map-v34-p")
+		testDeepEqualErr(v34v1, v34v2, t, "equal-map-v34-p")
+	}
+
+	for _, v := range []map[string]bool{nil, map[string]bool{}, map[string]bool{"some-string": true}} {
+		// fmt.Printf(">>>> running mammoth map v35: %v\n", v)
+		var v35v1, v35v2 map[string]bool
+		v35v1 = v
+		bs35, _ := testMarshalErr(v35v1, h, t, "enc-map-v35")
+		if v != nil {
+			v35v2 = make(map[string]bool, len(v))
+		}
+		testUnmarshalErr(v35v2, bs35, h, t, "dec-map-v35")
+		testDeepEqualErr(v35v1, v35v2, t, "equal-map-v35")
+		bs35, _ = testMarshalErr(&v35v1, h, t, "enc-map-v35-p")
+		v35v2 = nil
+		testUnmarshalErr(&v35v2, bs35, h, t, "dec-map-v35-p")
+		testDeepEqualErr(v35v1, v35v2, t, "equal-map-v35-p")
+	}
+
+	for _, v := range []map[float32]interface{}{nil, map[float32]interface{}{}, map[float32]interface{}{10.1: "string-is-an-interface"}} {
+		// fmt.Printf(">>>> running mammoth map v38: %v\n", v)
+		var v38v1, v38v2 map[float32]interface{}
+		v38v1 = v
+		bs38, _ := testMarshalErr(v38v1, h, t, "enc-map-v38")
+		if v != nil {
+			v38v2 = make(map[float32]interface{}, len(v))
+		}
+		testUnmarshalErr(v38v2, bs38, h, t, "dec-map-v38")
+		testDeepEqualErr(v38v1, v38v2, t, "equal-map-v38")
+		bs38, _ = testMarshalErr(&v38v1, h, t, "enc-map-v38-p")
+		v38v2 = nil
+		testUnmarshalErr(&v38v2, bs38, h, t, "dec-map-v38-p")
+		testDeepEqualErr(v38v1, v38v2, t, "equal-map-v38-p")
+	}
+
+	for _, v := range []map[float32]string{nil, map[float32]string{}, map[float32]string{10.1: "some-string"}} {
+		// fmt.Printf(">>>> running mammoth map v39: %v\n", v)
+		var v39v1, v39v2 map[float32]string
+		v39v1 = v
+		bs39, _ := testMarshalErr(v39v1, h, t, "enc-map-v39")
+		if v != nil {
+			v39v2 = make(map[float32]string, len(v))
+		}
+		testUnmarshalErr(v39v2, bs39, h, t, "dec-map-v39")
+		testDeepEqualErr(v39v1, v39v2, t, "equal-map-v39")
+		bs39, _ = testMarshalErr(&v39v1, h, t, "enc-map-v39-p")
+		v39v2 = nil
+		testUnmarshalErr(&v39v2, bs39, h, t, "dec-map-v39-p")
+		testDeepEqualErr(v39v1, v39v2, t, "equal-map-v39-p")
+	}
+
+	for _, v := range []map[float32]uint{nil, map[float32]uint{}, map[float32]uint{10.1: 10}} {
+		// fmt.Printf(">>>> running mammoth map v40: %v\n", v)
+		var v40v1, v40v2 map[float32]uint
+		v40v1 = v
+		bs40, _ := testMarshalErr(v40v1, h, t, "enc-map-v40")
+		if v != nil {
+			v40v2 = make(map[float32]uint, len(v))
+		}
+		testUnmarshalErr(v40v2, bs40, h, t, "dec-map-v40")
+		testDeepEqualErr(v40v1, v40v2, t, "equal-map-v40")
+		bs40, _ = testMarshalErr(&v40v1, h, t, "enc-map-v40-p")
+		v40v2 = nil
+		testUnmarshalErr(&v40v2, bs40, h, t, "dec-map-v40-p")
+		testDeepEqualErr(v40v1, v40v2, t, "equal-map-v40-p")
+	}
+
+	for _, v := range []map[float32]uint8{nil, map[float32]uint8{}, map[float32]uint8{10.1: 10}} {
+		// fmt.Printf(">>>> running mammoth map v41: %v\n", v)
+		var v41v1, v41v2 map[float32]uint8
+		v41v1 = v
+		bs41, _ := testMarshalErr(v41v1, h, t, "enc-map-v41")
+		if v != nil {
+			v41v2 = make(map[float32]uint8, len(v))
+		}
+		testUnmarshalErr(v41v2, bs41, h, t, "dec-map-v41")
+		testDeepEqualErr(v41v1, v41v2, t, "equal-map-v41")
+		bs41, _ = testMarshalErr(&v41v1, h, t, "enc-map-v41-p")
+		v41v2 = nil
+		testUnmarshalErr(&v41v2, bs41, h, t, "dec-map-v41-p")
+		testDeepEqualErr(v41v1, v41v2, t, "equal-map-v41-p")
+	}
+
+	for _, v := range []map[float32]uint16{nil, map[float32]uint16{}, map[float32]uint16{10.1: 10}} {
+		// fmt.Printf(">>>> running mammoth map v42: %v\n", v)
+		var v42v1, v42v2 map[float32]uint16
+		v42v1 = v
+		bs42, _ := testMarshalErr(v42v1, h, t, "enc-map-v42")
+		if v != nil {
+			v42v2 = make(map[float32]uint16, len(v))
+		}
+		testUnmarshalErr(v42v2, bs42, h, t, "dec-map-v42")
+		testDeepEqualErr(v42v1, v42v2, t, "equal-map-v42")
+		bs42, _ = testMarshalErr(&v42v1, h, t, "enc-map-v42-p")
+		v42v2 = nil
+		testUnmarshalErr(&v42v2, bs42, h, t, "dec-map-v42-p")
+		testDeepEqualErr(v42v1, v42v2, t, "equal-map-v42-p")
+	}
+
+	for _, v := range []map[float32]uint32{nil, map[float32]uint32{}, map[float32]uint32{10.1: 10}} {
+		// fmt.Printf(">>>> running mammoth map v43: %v\n", v)
+		var v43v1, v43v2 map[float32]uint32
+		v43v1 = v
+		bs43, _ := testMarshalErr(v43v1, h, t, "enc-map-v43")
+		if v != nil {
+			v43v2 = make(map[float32]uint32, len(v))
+		}
+		testUnmarshalErr(v43v2, bs43, h, t, "dec-map-v43")
+		testDeepEqualErr(v43v1, v43v2, t, "equal-map-v43")
+		bs43, _ = testMarshalErr(&v43v1, h, t, "enc-map-v43-p")
+		v43v2 = nil
+		testUnmarshalErr(&v43v2, bs43, h, t, "dec-map-v43-p")
+		testDeepEqualErr(v43v1, v43v2, t, "equal-map-v43-p")
+	}
+
+	for _, v := range []map[float32]uint64{nil, map[float32]uint64{}, map[float32]uint64{10.1: 10}} {
+		// fmt.Printf(">>>> running mammoth map v44: %v\n", v)
+		var v44v1, v44v2 map[float32]uint64
+		v44v1 = v
+		bs44, _ := testMarshalErr(v44v1, h, t, "enc-map-v44")
+		if v != nil {
+			v44v2 = make(map[float32]uint64, len(v))
+		}
+		testUnmarshalErr(v44v2, bs44, h, t, "dec-map-v44")
+		testDeepEqualErr(v44v1, v44v2, t, "equal-map-v44")
+		bs44, _ = testMarshalErr(&v44v1, h, t, "enc-map-v44-p")
+		v44v2 = nil
+		testUnmarshalErr(&v44v2, bs44, h, t, "dec-map-v44-p")
+		testDeepEqualErr(v44v1, v44v2, t, "equal-map-v44-p")
+	}
+
+	for _, v := range []map[float32]uintptr{nil, map[float32]uintptr{}, map[float32]uintptr{10.1: 10}} {
+		// fmt.Printf(">>>> running mammoth map v45: %v\n", v)
+		var v45v1, v45v2 map[float32]uintptr
+		v45v1 = v
+		bs45, _ := testMarshalErr(v45v1, h, t, "enc-map-v45")
+		if v != nil {
+			v45v2 = make(map[float32]uintptr, len(v))
+		}
+		testUnmarshalErr(v45v2, bs45, h, t, "dec-map-v45")
+		testDeepEqualErr(v45v1, v45v2, t, "equal-map-v45")
+		bs45, _ = testMarshalErr(&v45v1, h, t, "enc-map-v45-p")
+		v45v2 = nil
+		testUnmarshalErr(&v45v2, bs45, h, t, "dec-map-v45-p")
+		testDeepEqualErr(v45v1, v45v2, t, "equal-map-v45-p")
+	}
+
+	for _, v := range []map[float32]int{nil, map[float32]int{}, map[float32]int{10.1: 10}} {
+		// fmt.Printf(">>>> running mammoth map v46: %v\n", v)
+		var v46v1, v46v2 map[float32]int
+		v46v1 = v
+		bs46, _ := testMarshalErr(v46v1, h, t, "enc-map-v46")
+		if v != nil {
+			v46v2 = make(map[float32]int, len(v))
+		}
+		testUnmarshalErr(v46v2, bs46, h, t, "dec-map-v46")
+		testDeepEqualErr(v46v1, v46v2, t, "equal-map-v46")
+		bs46, _ = testMarshalErr(&v46v1, h, t, "enc-map-v46-p")
+		v46v2 = nil
+		testUnmarshalErr(&v46v2, bs46, h, t, "dec-map-v46-p")
+		testDeepEqualErr(v46v1, v46v2, t, "equal-map-v46-p")
+	}
+
+	for _, v := range []map[float32]int8{nil, map[float32]int8{}, map[float32]int8{10.1: 10}} {
+		// fmt.Printf(">>>> running mammoth map v47: %v\n", v)
+		var v47v1, v47v2 map[float32]int8
+		v47v1 = v
+		bs47, _ := testMarshalErr(v47v1, h, t, "enc-map-v47")
+		if v != nil {
+			v47v2 = make(map[float32]int8, len(v))
+		}
+		testUnmarshalErr(v47v2, bs47, h, t, "dec-map-v47")
+		testDeepEqualErr(v47v1, v47v2, t, "equal-map-v47")
+		bs47, _ = testMarshalErr(&v47v1, h, t, "enc-map-v47-p")
+		v47v2 = nil
+		testUnmarshalErr(&v47v2, bs47, h, t, "dec-map-v47-p")
+		testDeepEqualErr(v47v1, v47v2, t, "equal-map-v47-p")
+	}
+
+	for _, v := range []map[float32]int16{nil, map[float32]int16{}, map[float32]int16{10.1: 10}} {
+		// fmt.Printf(">>>> running mammoth map v48: %v\n", v)
+		var v48v1, v48v2 map[float32]int16
+		v48v1 = v
+		bs48, _ := testMarshalErr(v48v1, h, t, "enc-map-v48")
+		if v != nil {
+			v48v2 = make(map[float32]int16, len(v))
+		}
+		testUnmarshalErr(v48v2, bs48, h, t, "dec-map-v48")
+		testDeepEqualErr(v48v1, v48v2, t, "equal-map-v48")
+		bs48, _ = testMarshalErr(&v48v1, h, t, "enc-map-v48-p")
+		v48v2 = nil
+		testUnmarshalErr(&v48v2, bs48, h, t, "dec-map-v48-p")
+		testDeepEqualErr(v48v1, v48v2, t, "equal-map-v48-p")
+	}
+
+	for _, v := range []map[float32]int32{nil, map[float32]int32{}, map[float32]int32{10.1: 10}} {
+		// fmt.Printf(">>>> running mammoth map v49: %v\n", v)
+		var v49v1, v49v2 map[float32]int32
+		v49v1 = v
+		bs49, _ := testMarshalErr(v49v1, h, t, "enc-map-v49")
+		if v != nil {
+			v49v2 = make(map[float32]int32, len(v))
+		}
+		testUnmarshalErr(v49v2, bs49, h, t, "dec-map-v49")
+		testDeepEqualErr(v49v1, v49v2, t, "equal-map-v49")
+		bs49, _ = testMarshalErr(&v49v1, h, t, "enc-map-v49-p")
+		v49v2 = nil
+		testUnmarshalErr(&v49v2, bs49, h, t, "dec-map-v49-p")
+		testDeepEqualErr(v49v1, v49v2, t, "equal-map-v49-p")
+	}
+
+	for _, v := range []map[float32]int64{nil, map[float32]int64{}, map[float32]int64{10.1: 10}} {
+		// fmt.Printf(">>>> running mammoth map v50: %v\n", v)
+		var v50v1, v50v2 map[float32]int64
+		v50v1 = v
+		bs50, _ := testMarshalErr(v50v1, h, t, "enc-map-v50")
+		if v != nil {
+			v50v2 = make(map[float32]int64, len(v))
+		}
+		testUnmarshalErr(v50v2, bs50, h, t, "dec-map-v50")
+		testDeepEqualErr(v50v1, v50v2, t, "equal-map-v50")
+		bs50, _ = testMarshalErr(&v50v1, h, t, "enc-map-v50-p")
+		v50v2 = nil
+		testUnmarshalErr(&v50v2, bs50, h, t, "dec-map-v50-p")
+		testDeepEqualErr(v50v1, v50v2, t, "equal-map-v50-p")
+	}
+
+	for _, v := range []map[float32]float32{nil, map[float32]float32{}, map[float32]float32{10.1: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v51: %v\n", v)
+		var v51v1, v51v2 map[float32]float32
+		v51v1 = v
+		bs51, _ := testMarshalErr(v51v1, h, t, "enc-map-v51")
+		if v != nil {
+			v51v2 = make(map[float32]float32, len(v))
+		}
+		testUnmarshalErr(v51v2, bs51, h, t, "dec-map-v51")
+		testDeepEqualErr(v51v1, v51v2, t, "equal-map-v51")
+		bs51, _ = testMarshalErr(&v51v1, h, t, "enc-map-v51-p")
+		v51v2 = nil
+		testUnmarshalErr(&v51v2, bs51, h, t, "dec-map-v51-p")
+		testDeepEqualErr(v51v1, v51v2, t, "equal-map-v51-p")
+	}
+
+	for _, v := range []map[float32]float64{nil, map[float32]float64{}, map[float32]float64{10.1: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v52: %v\n", v)
+		var v52v1, v52v2 map[float32]float64
+		v52v1 = v
+		bs52, _ := testMarshalErr(v52v1, h, t, "enc-map-v52")
+		if v != nil {
+			v52v2 = make(map[float32]float64, len(v))
+		}
+		testUnmarshalErr(v52v2, bs52, h, t, "dec-map-v52")
+		testDeepEqualErr(v52v1, v52v2, t, "equal-map-v52")
+		bs52, _ = testMarshalErr(&v52v1, h, t, "enc-map-v52-p")
+		v52v2 = nil
+		testUnmarshalErr(&v52v2, bs52, h, t, "dec-map-v52-p")
+		testDeepEqualErr(v52v1, v52v2, t, "equal-map-v52-p")
+	}
+
+	for _, v := range []map[float32]bool{nil, map[float32]bool{}, map[float32]bool{10.1: true}} {
+		// fmt.Printf(">>>> running mammoth map v53: %v\n", v)
+		var v53v1, v53v2 map[float32]bool
+		v53v1 = v
+		bs53, _ := testMarshalErr(v53v1, h, t, "enc-map-v53")
+		if v != nil {
+			v53v2 = make(map[float32]bool, len(v))
+		}
+		testUnmarshalErr(v53v2, bs53, h, t, "dec-map-v53")
+		testDeepEqualErr(v53v1, v53v2, t, "equal-map-v53")
+		bs53, _ = testMarshalErr(&v53v1, h, t, "enc-map-v53-p")
+		v53v2 = nil
+		testUnmarshalErr(&v53v2, bs53, h, t, "dec-map-v53-p")
+		testDeepEqualErr(v53v1, v53v2, t, "equal-map-v53-p")
+	}
+
+	for _, v := range []map[float64]interface{}{nil, map[float64]interface{}{}, map[float64]interface{}{10.1: "string-is-an-interface"}} {
+		// fmt.Printf(">>>> running mammoth map v56: %v\n", v)
+		var v56v1, v56v2 map[float64]interface{}
+		v56v1 = v
+		bs56, _ := testMarshalErr(v56v1, h, t, "enc-map-v56")
+		if v != nil {
+			v56v2 = make(map[float64]interface{}, len(v))
+		}
+		testUnmarshalErr(v56v2, bs56, h, t, "dec-map-v56")
+		testDeepEqualErr(v56v1, v56v2, t, "equal-map-v56")
+		bs56, _ = testMarshalErr(&v56v1, h, t, "enc-map-v56-p")
+		v56v2 = nil
+		testUnmarshalErr(&v56v2, bs56, h, t, "dec-map-v56-p")
+		testDeepEqualErr(v56v1, v56v2, t, "equal-map-v56-p")
+	}
+
+	for _, v := range []map[float64]string{nil, map[float64]string{}, map[float64]string{10.1: "some-string"}} {
+		// fmt.Printf(">>>> running mammoth map v57: %v\n", v)
+		var v57v1, v57v2 map[float64]string
+		v57v1 = v
+		bs57, _ := testMarshalErr(v57v1, h, t, "enc-map-v57")
+		if v != nil {
+			v57v2 = make(map[float64]string, len(v))
+		}
+		testUnmarshalErr(v57v2, bs57, h, t, "dec-map-v57")
+		testDeepEqualErr(v57v1, v57v2, t, "equal-map-v57")
+		bs57, _ = testMarshalErr(&v57v1, h, t, "enc-map-v57-p")
+		v57v2 = nil
+		testUnmarshalErr(&v57v2, bs57, h, t, "dec-map-v57-p")
+		testDeepEqualErr(v57v1, v57v2, t, "equal-map-v57-p")
+	}
+
+	for _, v := range []map[float64]uint{nil, map[float64]uint{}, map[float64]uint{10.1: 10}} {
+		// fmt.Printf(">>>> running mammoth map v58: %v\n", v)
+		var v58v1, v58v2 map[float64]uint
+		v58v1 = v
+		bs58, _ := testMarshalErr(v58v1, h, t, "enc-map-v58")
+		if v != nil {
+			v58v2 = make(map[float64]uint, len(v))
+		}
+		testUnmarshalErr(v58v2, bs58, h, t, "dec-map-v58")
+		testDeepEqualErr(v58v1, v58v2, t, "equal-map-v58")
+		bs58, _ = testMarshalErr(&v58v1, h, t, "enc-map-v58-p")
+		v58v2 = nil
+		testUnmarshalErr(&v58v2, bs58, h, t, "dec-map-v58-p")
+		testDeepEqualErr(v58v1, v58v2, t, "equal-map-v58-p")
+	}
+
+	for _, v := range []map[float64]uint8{nil, map[float64]uint8{}, map[float64]uint8{10.1: 10}} {
+		// fmt.Printf(">>>> running mammoth map v59: %v\n", v)
+		var v59v1, v59v2 map[float64]uint8
+		v59v1 = v
+		bs59, _ := testMarshalErr(v59v1, h, t, "enc-map-v59")
+		if v != nil {
+			v59v2 = make(map[float64]uint8, len(v))
+		}
+		testUnmarshalErr(v59v2, bs59, h, t, "dec-map-v59")
+		testDeepEqualErr(v59v1, v59v2, t, "equal-map-v59")
+		bs59, _ = testMarshalErr(&v59v1, h, t, "enc-map-v59-p")
+		v59v2 = nil
+		testUnmarshalErr(&v59v2, bs59, h, t, "dec-map-v59-p")
+		testDeepEqualErr(v59v1, v59v2, t, "equal-map-v59-p")
+	}
+
+	for _, v := range []map[float64]uint16{nil, map[float64]uint16{}, map[float64]uint16{10.1: 10}} {
+		// fmt.Printf(">>>> running mammoth map v60: %v\n", v)
+		var v60v1, v60v2 map[float64]uint16
+		v60v1 = v
+		bs60, _ := testMarshalErr(v60v1, h, t, "enc-map-v60")
+		if v != nil {
+			v60v2 = make(map[float64]uint16, len(v))
+		}
+		testUnmarshalErr(v60v2, bs60, h, t, "dec-map-v60")
+		testDeepEqualErr(v60v1, v60v2, t, "equal-map-v60")
+		bs60, _ = testMarshalErr(&v60v1, h, t, "enc-map-v60-p")
+		v60v2 = nil
+		testUnmarshalErr(&v60v2, bs60, h, t, "dec-map-v60-p")
+		testDeepEqualErr(v60v1, v60v2, t, "equal-map-v60-p")
+	}
+
+	for _, v := range []map[float64]uint32{nil, map[float64]uint32{}, map[float64]uint32{10.1: 10}} {
+		// fmt.Printf(">>>> running mammoth map v61: %v\n", v)
+		var v61v1, v61v2 map[float64]uint32
+		v61v1 = v
+		bs61, _ := testMarshalErr(v61v1, h, t, "enc-map-v61")
+		if v != nil {
+			v61v2 = make(map[float64]uint32, len(v))
+		}
+		testUnmarshalErr(v61v2, bs61, h, t, "dec-map-v61")
+		testDeepEqualErr(v61v1, v61v2, t, "equal-map-v61")
+		bs61, _ = testMarshalErr(&v61v1, h, t, "enc-map-v61-p")
+		v61v2 = nil
+		testUnmarshalErr(&v61v2, bs61, h, t, "dec-map-v61-p")
+		testDeepEqualErr(v61v1, v61v2, t, "equal-map-v61-p")
+	}
+
+	for _, v := range []map[float64]uint64{nil, map[float64]uint64{}, map[float64]uint64{10.1: 10}} {
+		// fmt.Printf(">>>> running mammoth map v62: %v\n", v)
+		var v62v1, v62v2 map[float64]uint64
+		v62v1 = v
+		bs62, _ := testMarshalErr(v62v1, h, t, "enc-map-v62")
+		if v != nil {
+			v62v2 = make(map[float64]uint64, len(v))
+		}
+		testUnmarshalErr(v62v2, bs62, h, t, "dec-map-v62")
+		testDeepEqualErr(v62v1, v62v2, t, "equal-map-v62")
+		bs62, _ = testMarshalErr(&v62v1, h, t, "enc-map-v62-p")
+		v62v2 = nil
+		testUnmarshalErr(&v62v2, bs62, h, t, "dec-map-v62-p")
+		testDeepEqualErr(v62v1, v62v2, t, "equal-map-v62-p")
+	}
+
+	for _, v := range []map[float64]uintptr{nil, map[float64]uintptr{}, map[float64]uintptr{10.1: 10}} {
+		// fmt.Printf(">>>> running mammoth map v63: %v\n", v)
+		var v63v1, v63v2 map[float64]uintptr
+		v63v1 = v
+		bs63, _ := testMarshalErr(v63v1, h, t, "enc-map-v63")
+		if v != nil {
+			v63v2 = make(map[float64]uintptr, len(v))
+		}
+		testUnmarshalErr(v63v2, bs63, h, t, "dec-map-v63")
+		testDeepEqualErr(v63v1, v63v2, t, "equal-map-v63")
+		bs63, _ = testMarshalErr(&v63v1, h, t, "enc-map-v63-p")
+		v63v2 = nil
+		testUnmarshalErr(&v63v2, bs63, h, t, "dec-map-v63-p")
+		testDeepEqualErr(v63v1, v63v2, t, "equal-map-v63-p")
+	}
+
+	for _, v := range []map[float64]int{nil, map[float64]int{}, map[float64]int{10.1: 10}} {
+		// fmt.Printf(">>>> running mammoth map v64: %v\n", v)
+		var v64v1, v64v2 map[float64]int
+		v64v1 = v
+		bs64, _ := testMarshalErr(v64v1, h, t, "enc-map-v64")
+		if v != nil {
+			v64v2 = make(map[float64]int, len(v))
+		}
+		testUnmarshalErr(v64v2, bs64, h, t, "dec-map-v64")
+		testDeepEqualErr(v64v1, v64v2, t, "equal-map-v64")
+		bs64, _ = testMarshalErr(&v64v1, h, t, "enc-map-v64-p")
+		v64v2 = nil
+		testUnmarshalErr(&v64v2, bs64, h, t, "dec-map-v64-p")
+		testDeepEqualErr(v64v1, v64v2, t, "equal-map-v64-p")
+	}
+
+	for _, v := range []map[float64]int8{nil, map[float64]int8{}, map[float64]int8{10.1: 10}} {
+		// fmt.Printf(">>>> running mammoth map v65: %v\n", v)
+		var v65v1, v65v2 map[float64]int8
+		v65v1 = v
+		bs65, _ := testMarshalErr(v65v1, h, t, "enc-map-v65")
+		if v != nil {
+			v65v2 = make(map[float64]int8, len(v))
+		}
+		testUnmarshalErr(v65v2, bs65, h, t, "dec-map-v65")
+		testDeepEqualErr(v65v1, v65v2, t, "equal-map-v65")
+		bs65, _ = testMarshalErr(&v65v1, h, t, "enc-map-v65-p")
+		v65v2 = nil
+		testUnmarshalErr(&v65v2, bs65, h, t, "dec-map-v65-p")
+		testDeepEqualErr(v65v1, v65v2, t, "equal-map-v65-p")
+	}
+
+	for _, v := range []map[float64]int16{nil, map[float64]int16{}, map[float64]int16{10.1: 10}} {
+		// fmt.Printf(">>>> running mammoth map v66: %v\n", v)
+		var v66v1, v66v2 map[float64]int16
+		v66v1 = v
+		bs66, _ := testMarshalErr(v66v1, h, t, "enc-map-v66")
+		if v != nil {
+			v66v2 = make(map[float64]int16, len(v))
+		}
+		testUnmarshalErr(v66v2, bs66, h, t, "dec-map-v66")
+		testDeepEqualErr(v66v1, v66v2, t, "equal-map-v66")
+		bs66, _ = testMarshalErr(&v66v1, h, t, "enc-map-v66-p")
+		v66v2 = nil
+		testUnmarshalErr(&v66v2, bs66, h, t, "dec-map-v66-p")
+		testDeepEqualErr(v66v1, v66v2, t, "equal-map-v66-p")
+	}
+
+	for _, v := range []map[float64]int32{nil, map[float64]int32{}, map[float64]int32{10.1: 10}} {
+		// fmt.Printf(">>>> running mammoth map v67: %v\n", v)
+		var v67v1, v67v2 map[float64]int32
+		v67v1 = v
+		bs67, _ := testMarshalErr(v67v1, h, t, "enc-map-v67")
+		if v != nil {
+			v67v2 = make(map[float64]int32, len(v))
+		}
+		testUnmarshalErr(v67v2, bs67, h, t, "dec-map-v67")
+		testDeepEqualErr(v67v1, v67v2, t, "equal-map-v67")
+		bs67, _ = testMarshalErr(&v67v1, h, t, "enc-map-v67-p")
+		v67v2 = nil
+		testUnmarshalErr(&v67v2, bs67, h, t, "dec-map-v67-p")
+		testDeepEqualErr(v67v1, v67v2, t, "equal-map-v67-p")
+	}
+
+	for _, v := range []map[float64]int64{nil, map[float64]int64{}, map[float64]int64{10.1: 10}} {
+		// fmt.Printf(">>>> running mammoth map v68: %v\n", v)
+		var v68v1, v68v2 map[float64]int64
+		v68v1 = v
+		bs68, _ := testMarshalErr(v68v1, h, t, "enc-map-v68")
+		if v != nil {
+			v68v2 = make(map[float64]int64, len(v))
+		}
+		testUnmarshalErr(v68v2, bs68, h, t, "dec-map-v68")
+		testDeepEqualErr(v68v1, v68v2, t, "equal-map-v68")
+		bs68, _ = testMarshalErr(&v68v1, h, t, "enc-map-v68-p")
+		v68v2 = nil
+		testUnmarshalErr(&v68v2, bs68, h, t, "dec-map-v68-p")
+		testDeepEqualErr(v68v1, v68v2, t, "equal-map-v68-p")
+	}
+
+	for _, v := range []map[float64]float32{nil, map[float64]float32{}, map[float64]float32{10.1: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v69: %v\n", v)
+		var v69v1, v69v2 map[float64]float32
+		v69v1 = v
+		bs69, _ := testMarshalErr(v69v1, h, t, "enc-map-v69")
+		if v != nil {
+			v69v2 = make(map[float64]float32, len(v))
+		}
+		testUnmarshalErr(v69v2, bs69, h, t, "dec-map-v69")
+		testDeepEqualErr(v69v1, v69v2, t, "equal-map-v69")
+		bs69, _ = testMarshalErr(&v69v1, h, t, "enc-map-v69-p")
+		v69v2 = nil
+		testUnmarshalErr(&v69v2, bs69, h, t, "dec-map-v69-p")
+		testDeepEqualErr(v69v1, v69v2, t, "equal-map-v69-p")
+	}
+
+	for _, v := range []map[float64]float64{nil, map[float64]float64{}, map[float64]float64{10.1: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v70: %v\n", v)
+		var v70v1, v70v2 map[float64]float64
+		v70v1 = v
+		bs70, _ := testMarshalErr(v70v1, h, t, "enc-map-v70")
+		if v != nil {
+			v70v2 = make(map[float64]float64, len(v))
+		}
+		testUnmarshalErr(v70v2, bs70, h, t, "dec-map-v70")
+		testDeepEqualErr(v70v1, v70v2, t, "equal-map-v70")
+		bs70, _ = testMarshalErr(&v70v1, h, t, "enc-map-v70-p")
+		v70v2 = nil
+		testUnmarshalErr(&v70v2, bs70, h, t, "dec-map-v70-p")
+		testDeepEqualErr(v70v1, v70v2, t, "equal-map-v70-p")
+	}
+
+	for _, v := range []map[float64]bool{nil, map[float64]bool{}, map[float64]bool{10.1: true}} {
+		// fmt.Printf(">>>> running mammoth map v71: %v\n", v)
+		var v71v1, v71v2 map[float64]bool
+		v71v1 = v
+		bs71, _ := testMarshalErr(v71v1, h, t, "enc-map-v71")
+		if v != nil {
+			v71v2 = make(map[float64]bool, len(v))
+		}
+		testUnmarshalErr(v71v2, bs71, h, t, "dec-map-v71")
+		testDeepEqualErr(v71v1, v71v2, t, "equal-map-v71")
+		bs71, _ = testMarshalErr(&v71v1, h, t, "enc-map-v71-p")
+		v71v2 = nil
+		testUnmarshalErr(&v71v2, bs71, h, t, "dec-map-v71-p")
+		testDeepEqualErr(v71v1, v71v2, t, "equal-map-v71-p")
+	}
+
+	for _, v := range []map[uint]interface{}{nil, map[uint]interface{}{}, map[uint]interface{}{10: "string-is-an-interface"}} {
+		// fmt.Printf(">>>> running mammoth map v74: %v\n", v)
+		var v74v1, v74v2 map[uint]interface{}
+		v74v1 = v
+		bs74, _ := testMarshalErr(v74v1, h, t, "enc-map-v74")
+		if v != nil {
+			v74v2 = make(map[uint]interface{}, len(v))
+		}
+		testUnmarshalErr(v74v2, bs74, h, t, "dec-map-v74")
+		testDeepEqualErr(v74v1, v74v2, t, "equal-map-v74")
+		bs74, _ = testMarshalErr(&v74v1, h, t, "enc-map-v74-p")
+		v74v2 = nil
+		testUnmarshalErr(&v74v2, bs74, h, t, "dec-map-v74-p")
+		testDeepEqualErr(v74v1, v74v2, t, "equal-map-v74-p")
+	}
+
+	for _, v := range []map[uint]string{nil, map[uint]string{}, map[uint]string{10: "some-string"}} {
+		// fmt.Printf(">>>> running mammoth map v75: %v\n", v)
+		var v75v1, v75v2 map[uint]string
+		v75v1 = v
+		bs75, _ := testMarshalErr(v75v1, h, t, "enc-map-v75")
+		if v != nil {
+			v75v2 = make(map[uint]string, len(v))
+		}
+		testUnmarshalErr(v75v2, bs75, h, t, "dec-map-v75")
+		testDeepEqualErr(v75v1, v75v2, t, "equal-map-v75")
+		bs75, _ = testMarshalErr(&v75v1, h, t, "enc-map-v75-p")
+		v75v2 = nil
+		testUnmarshalErr(&v75v2, bs75, h, t, "dec-map-v75-p")
+		testDeepEqualErr(v75v1, v75v2, t, "equal-map-v75-p")
+	}
+
+	for _, v := range []map[uint]uint{nil, map[uint]uint{}, map[uint]uint{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v76: %v\n", v)
+		var v76v1, v76v2 map[uint]uint
+		v76v1 = v
+		bs76, _ := testMarshalErr(v76v1, h, t, "enc-map-v76")
+		if v != nil {
+			v76v2 = make(map[uint]uint, len(v))
+		}
+		testUnmarshalErr(v76v2, bs76, h, t, "dec-map-v76")
+		testDeepEqualErr(v76v1, v76v2, t, "equal-map-v76")
+		bs76, _ = testMarshalErr(&v76v1, h, t, "enc-map-v76-p")
+		v76v2 = nil
+		testUnmarshalErr(&v76v2, bs76, h, t, "dec-map-v76-p")
+		testDeepEqualErr(v76v1, v76v2, t, "equal-map-v76-p")
+	}
+
+	for _, v := range []map[uint]uint8{nil, map[uint]uint8{}, map[uint]uint8{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v77: %v\n", v)
+		var v77v1, v77v2 map[uint]uint8
+		v77v1 = v
+		bs77, _ := testMarshalErr(v77v1, h, t, "enc-map-v77")
+		if v != nil {
+			v77v2 = make(map[uint]uint8, len(v))
+		}
+		testUnmarshalErr(v77v2, bs77, h, t, "dec-map-v77")
+		testDeepEqualErr(v77v1, v77v2, t, "equal-map-v77")
+		bs77, _ = testMarshalErr(&v77v1, h, t, "enc-map-v77-p")
+		v77v2 = nil
+		testUnmarshalErr(&v77v2, bs77, h, t, "dec-map-v77-p")
+		testDeepEqualErr(v77v1, v77v2, t, "equal-map-v77-p")
+	}
+
+	for _, v := range []map[uint]uint16{nil, map[uint]uint16{}, map[uint]uint16{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v78: %v\n", v)
+		var v78v1, v78v2 map[uint]uint16
+		v78v1 = v
+		bs78, _ := testMarshalErr(v78v1, h, t, "enc-map-v78")
+		if v != nil {
+			v78v2 = make(map[uint]uint16, len(v))
+		}
+		testUnmarshalErr(v78v2, bs78, h, t, "dec-map-v78")
+		testDeepEqualErr(v78v1, v78v2, t, "equal-map-v78")
+		bs78, _ = testMarshalErr(&v78v1, h, t, "enc-map-v78-p")
+		v78v2 = nil
+		testUnmarshalErr(&v78v2, bs78, h, t, "dec-map-v78-p")
+		testDeepEqualErr(v78v1, v78v2, t, "equal-map-v78-p")
+	}
+
+	for _, v := range []map[uint]uint32{nil, map[uint]uint32{}, map[uint]uint32{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v79: %v\n", v)
+		var v79v1, v79v2 map[uint]uint32
+		v79v1 = v
+		bs79, _ := testMarshalErr(v79v1, h, t, "enc-map-v79")
+		if v != nil {
+			v79v2 = make(map[uint]uint32, len(v))
+		}
+		testUnmarshalErr(v79v2, bs79, h, t, "dec-map-v79")
+		testDeepEqualErr(v79v1, v79v2, t, "equal-map-v79")
+		bs79, _ = testMarshalErr(&v79v1, h, t, "enc-map-v79-p")
+		v79v2 = nil
+		testUnmarshalErr(&v79v2, bs79, h, t, "dec-map-v79-p")
+		testDeepEqualErr(v79v1, v79v2, t, "equal-map-v79-p")
+	}
+
+	for _, v := range []map[uint]uint64{nil, map[uint]uint64{}, map[uint]uint64{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v80: %v\n", v)
+		var v80v1, v80v2 map[uint]uint64
+		v80v1 = v
+		bs80, _ := testMarshalErr(v80v1, h, t, "enc-map-v80")
+		if v != nil {
+			v80v2 = make(map[uint]uint64, len(v))
+		}
+		testUnmarshalErr(v80v2, bs80, h, t, "dec-map-v80")
+		testDeepEqualErr(v80v1, v80v2, t, "equal-map-v80")
+		bs80, _ = testMarshalErr(&v80v1, h, t, "enc-map-v80-p")
+		v80v2 = nil
+		testUnmarshalErr(&v80v2, bs80, h, t, "dec-map-v80-p")
+		testDeepEqualErr(v80v1, v80v2, t, "equal-map-v80-p")
+	}
+
+	for _, v := range []map[uint]uintptr{nil, map[uint]uintptr{}, map[uint]uintptr{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v81: %v\n", v)
+		var v81v1, v81v2 map[uint]uintptr
+		v81v1 = v
+		bs81, _ := testMarshalErr(v81v1, h, t, "enc-map-v81")
+		if v != nil {
+			v81v2 = make(map[uint]uintptr, len(v))
+		}
+		testUnmarshalErr(v81v2, bs81, h, t, "dec-map-v81")
+		testDeepEqualErr(v81v1, v81v2, t, "equal-map-v81")
+		bs81, _ = testMarshalErr(&v81v1, h, t, "enc-map-v81-p")
+		v81v2 = nil
+		testUnmarshalErr(&v81v2, bs81, h, t, "dec-map-v81-p")
+		testDeepEqualErr(v81v1, v81v2, t, "equal-map-v81-p")
+	}
+
+	for _, v := range []map[uint]int{nil, map[uint]int{}, map[uint]int{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v82: %v\n", v)
+		var v82v1, v82v2 map[uint]int
+		v82v1 = v
+		bs82, _ := testMarshalErr(v82v1, h, t, "enc-map-v82")
+		if v != nil {
+			v82v2 = make(map[uint]int, len(v))
+		}
+		testUnmarshalErr(v82v2, bs82, h, t, "dec-map-v82")
+		testDeepEqualErr(v82v1, v82v2, t, "equal-map-v82")
+		bs82, _ = testMarshalErr(&v82v1, h, t, "enc-map-v82-p")
+		v82v2 = nil
+		testUnmarshalErr(&v82v2, bs82, h, t, "dec-map-v82-p")
+		testDeepEqualErr(v82v1, v82v2, t, "equal-map-v82-p")
+	}
+
+	for _, v := range []map[uint]int8{nil, map[uint]int8{}, map[uint]int8{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v83: %v\n", v)
+		var v83v1, v83v2 map[uint]int8
+		v83v1 = v
+		bs83, _ := testMarshalErr(v83v1, h, t, "enc-map-v83")
+		if v != nil {
+			v83v2 = make(map[uint]int8, len(v))
+		}
+		testUnmarshalErr(v83v2, bs83, h, t, "dec-map-v83")
+		testDeepEqualErr(v83v1, v83v2, t, "equal-map-v83")
+		bs83, _ = testMarshalErr(&v83v1, h, t, "enc-map-v83-p")
+		v83v2 = nil
+		testUnmarshalErr(&v83v2, bs83, h, t, "dec-map-v83-p")
+		testDeepEqualErr(v83v1, v83v2, t, "equal-map-v83-p")
+	}
+
+	for _, v := range []map[uint]int16{nil, map[uint]int16{}, map[uint]int16{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v84: %v\n", v)
+		var v84v1, v84v2 map[uint]int16
+		v84v1 = v
+		bs84, _ := testMarshalErr(v84v1, h, t, "enc-map-v84")
+		if v != nil {
+			v84v2 = make(map[uint]int16, len(v))
+		}
+		testUnmarshalErr(v84v2, bs84, h, t, "dec-map-v84")
+		testDeepEqualErr(v84v1, v84v2, t, "equal-map-v84")
+		bs84, _ = testMarshalErr(&v84v1, h, t, "enc-map-v84-p")
+		v84v2 = nil
+		testUnmarshalErr(&v84v2, bs84, h, t, "dec-map-v84-p")
+		testDeepEqualErr(v84v1, v84v2, t, "equal-map-v84-p")
+	}
+
+	for _, v := range []map[uint]int32{nil, map[uint]int32{}, map[uint]int32{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v85: %v\n", v)
+		var v85v1, v85v2 map[uint]int32
+		v85v1 = v
+		bs85, _ := testMarshalErr(v85v1, h, t, "enc-map-v85")
+		if v != nil {
+			v85v2 = make(map[uint]int32, len(v))
+		}
+		testUnmarshalErr(v85v2, bs85, h, t, "dec-map-v85")
+		testDeepEqualErr(v85v1, v85v2, t, "equal-map-v85")
+		bs85, _ = testMarshalErr(&v85v1, h, t, "enc-map-v85-p")
+		v85v2 = nil
+		testUnmarshalErr(&v85v2, bs85, h, t, "dec-map-v85-p")
+		testDeepEqualErr(v85v1, v85v2, t, "equal-map-v85-p")
+	}
+
+	for _, v := range []map[uint]int64{nil, map[uint]int64{}, map[uint]int64{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v86: %v\n", v)
+		var v86v1, v86v2 map[uint]int64
+		v86v1 = v
+		bs86, _ := testMarshalErr(v86v1, h, t, "enc-map-v86")
+		if v != nil {
+			v86v2 = make(map[uint]int64, len(v))
+		}
+		testUnmarshalErr(v86v2, bs86, h, t, "dec-map-v86")
+		testDeepEqualErr(v86v1, v86v2, t, "equal-map-v86")
+		bs86, _ = testMarshalErr(&v86v1, h, t, "enc-map-v86-p")
+		v86v2 = nil
+		testUnmarshalErr(&v86v2, bs86, h, t, "dec-map-v86-p")
+		testDeepEqualErr(v86v1, v86v2, t, "equal-map-v86-p")
+	}
+
+	for _, v := range []map[uint]float32{nil, map[uint]float32{}, map[uint]float32{10: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v87: %v\n", v)
+		var v87v1, v87v2 map[uint]float32
+		v87v1 = v
+		bs87, _ := testMarshalErr(v87v1, h, t, "enc-map-v87")
+		if v != nil {
+			v87v2 = make(map[uint]float32, len(v))
+		}
+		testUnmarshalErr(v87v2, bs87, h, t, "dec-map-v87")
+		testDeepEqualErr(v87v1, v87v2, t, "equal-map-v87")
+		bs87, _ = testMarshalErr(&v87v1, h, t, "enc-map-v87-p")
+		v87v2 = nil
+		testUnmarshalErr(&v87v2, bs87, h, t, "dec-map-v87-p")
+		testDeepEqualErr(v87v1, v87v2, t, "equal-map-v87-p")
+	}
+
+	for _, v := range []map[uint]float64{nil, map[uint]float64{}, map[uint]float64{10: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v88: %v\n", v)
+		var v88v1, v88v2 map[uint]float64
+		v88v1 = v
+		bs88, _ := testMarshalErr(v88v1, h, t, "enc-map-v88")
+		if v != nil {
+			v88v2 = make(map[uint]float64, len(v))
+		}
+		testUnmarshalErr(v88v2, bs88, h, t, "dec-map-v88")
+		testDeepEqualErr(v88v1, v88v2, t, "equal-map-v88")
+		bs88, _ = testMarshalErr(&v88v1, h, t, "enc-map-v88-p")
+		v88v2 = nil
+		testUnmarshalErr(&v88v2, bs88, h, t, "dec-map-v88-p")
+		testDeepEqualErr(v88v1, v88v2, t, "equal-map-v88-p")
+	}
+
+	for _, v := range []map[uint]bool{nil, map[uint]bool{}, map[uint]bool{10: true}} {
+		// fmt.Printf(">>>> running mammoth map v89: %v\n", v)
+		var v89v1, v89v2 map[uint]bool
+		v89v1 = v
+		bs89, _ := testMarshalErr(v89v1, h, t, "enc-map-v89")
+		if v != nil {
+			v89v2 = make(map[uint]bool, len(v))
+		}
+		testUnmarshalErr(v89v2, bs89, h, t, "dec-map-v89")
+		testDeepEqualErr(v89v1, v89v2, t, "equal-map-v89")
+		bs89, _ = testMarshalErr(&v89v1, h, t, "enc-map-v89-p")
+		v89v2 = nil
+		testUnmarshalErr(&v89v2, bs89, h, t, "dec-map-v89-p")
+		testDeepEqualErr(v89v1, v89v2, t, "equal-map-v89-p")
+	}
+
+	for _, v := range []map[uint8]interface{}{nil, map[uint8]interface{}{}, map[uint8]interface{}{10: "string-is-an-interface"}} {
+		// fmt.Printf(">>>> running mammoth map v91: %v\n", v)
+		var v91v1, v91v2 map[uint8]interface{}
+		v91v1 = v
+		bs91, _ := testMarshalErr(v91v1, h, t, "enc-map-v91")
+		if v != nil {
+			v91v2 = make(map[uint8]interface{}, len(v))
+		}
+		testUnmarshalErr(v91v2, bs91, h, t, "dec-map-v91")
+		testDeepEqualErr(v91v1, v91v2, t, "equal-map-v91")
+		bs91, _ = testMarshalErr(&v91v1, h, t, "enc-map-v91-p")
+		v91v2 = nil
+		testUnmarshalErr(&v91v2, bs91, h, t, "dec-map-v91-p")
+		testDeepEqualErr(v91v1, v91v2, t, "equal-map-v91-p")
+	}
+
+	for _, v := range []map[uint8]string{nil, map[uint8]string{}, map[uint8]string{10: "some-string"}} {
+		// fmt.Printf(">>>> running mammoth map v92: %v\n", v)
+		var v92v1, v92v2 map[uint8]string
+		v92v1 = v
+		bs92, _ := testMarshalErr(v92v1, h, t, "enc-map-v92")
+		if v != nil {
+			v92v2 = make(map[uint8]string, len(v))
+		}
+		testUnmarshalErr(v92v2, bs92, h, t, "dec-map-v92")
+		testDeepEqualErr(v92v1, v92v2, t, "equal-map-v92")
+		bs92, _ = testMarshalErr(&v92v1, h, t, "enc-map-v92-p")
+		v92v2 = nil
+		testUnmarshalErr(&v92v2, bs92, h, t, "dec-map-v92-p")
+		testDeepEqualErr(v92v1, v92v2, t, "equal-map-v92-p")
+	}
+
+	for _, v := range []map[uint8]uint{nil, map[uint8]uint{}, map[uint8]uint{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v93: %v\n", v)
+		var v93v1, v93v2 map[uint8]uint
+		v93v1 = v
+		bs93, _ := testMarshalErr(v93v1, h, t, "enc-map-v93")
+		if v != nil {
+			v93v2 = make(map[uint8]uint, len(v))
+		}
+		testUnmarshalErr(v93v2, bs93, h, t, "dec-map-v93")
+		testDeepEqualErr(v93v1, v93v2, t, "equal-map-v93")
+		bs93, _ = testMarshalErr(&v93v1, h, t, "enc-map-v93-p")
+		v93v2 = nil
+		testUnmarshalErr(&v93v2, bs93, h, t, "dec-map-v93-p")
+		testDeepEqualErr(v93v1, v93v2, t, "equal-map-v93-p")
+	}
+
+	for _, v := range []map[uint8]uint8{nil, map[uint8]uint8{}, map[uint8]uint8{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v94: %v\n", v)
+		var v94v1, v94v2 map[uint8]uint8
+		v94v1 = v
+		bs94, _ := testMarshalErr(v94v1, h, t, "enc-map-v94")
+		if v != nil {
+			v94v2 = make(map[uint8]uint8, len(v))
+		}
+		testUnmarshalErr(v94v2, bs94, h, t, "dec-map-v94")
+		testDeepEqualErr(v94v1, v94v2, t, "equal-map-v94")
+		bs94, _ = testMarshalErr(&v94v1, h, t, "enc-map-v94-p")
+		v94v2 = nil
+		testUnmarshalErr(&v94v2, bs94, h, t, "dec-map-v94-p")
+		testDeepEqualErr(v94v1, v94v2, t, "equal-map-v94-p")
+	}
+
+	for _, v := range []map[uint8]uint16{nil, map[uint8]uint16{}, map[uint8]uint16{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v95: %v\n", v)
+		var v95v1, v95v2 map[uint8]uint16
+		v95v1 = v
+		bs95, _ := testMarshalErr(v95v1, h, t, "enc-map-v95")
+		if v != nil {
+			v95v2 = make(map[uint8]uint16, len(v))
+		}
+		testUnmarshalErr(v95v2, bs95, h, t, "dec-map-v95")
+		testDeepEqualErr(v95v1, v95v2, t, "equal-map-v95")
+		bs95, _ = testMarshalErr(&v95v1, h, t, "enc-map-v95-p")
+		v95v2 = nil
+		testUnmarshalErr(&v95v2, bs95, h, t, "dec-map-v95-p")
+		testDeepEqualErr(v95v1, v95v2, t, "equal-map-v95-p")
+	}
+
+	for _, v := range []map[uint8]uint32{nil, map[uint8]uint32{}, map[uint8]uint32{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v96: %v\n", v)
+		var v96v1, v96v2 map[uint8]uint32
+		v96v1 = v
+		bs96, _ := testMarshalErr(v96v1, h, t, "enc-map-v96")
+		if v != nil {
+			v96v2 = make(map[uint8]uint32, len(v))
+		}
+		testUnmarshalErr(v96v2, bs96, h, t, "dec-map-v96")
+		testDeepEqualErr(v96v1, v96v2, t, "equal-map-v96")
+		bs96, _ = testMarshalErr(&v96v1, h, t, "enc-map-v96-p")
+		v96v2 = nil
+		testUnmarshalErr(&v96v2, bs96, h, t, "dec-map-v96-p")
+		testDeepEqualErr(v96v1, v96v2, t, "equal-map-v96-p")
+	}
+
+	for _, v := range []map[uint8]uint64{nil, map[uint8]uint64{}, map[uint8]uint64{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v97: %v\n", v)
+		var v97v1, v97v2 map[uint8]uint64
+		v97v1 = v
+		bs97, _ := testMarshalErr(v97v1, h, t, "enc-map-v97")
+		if v != nil {
+			v97v2 = make(map[uint8]uint64, len(v))
+		}
+		testUnmarshalErr(v97v2, bs97, h, t, "dec-map-v97")
+		testDeepEqualErr(v97v1, v97v2, t, "equal-map-v97")
+		bs97, _ = testMarshalErr(&v97v1, h, t, "enc-map-v97-p")
+		v97v2 = nil
+		testUnmarshalErr(&v97v2, bs97, h, t, "dec-map-v97-p")
+		testDeepEqualErr(v97v1, v97v2, t, "equal-map-v97-p")
+	}
+
+	for _, v := range []map[uint8]uintptr{nil, map[uint8]uintptr{}, map[uint8]uintptr{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v98: %v\n", v)
+		var v98v1, v98v2 map[uint8]uintptr
+		v98v1 = v
+		bs98, _ := testMarshalErr(v98v1, h, t, "enc-map-v98")
+		if v != nil {
+			v98v2 = make(map[uint8]uintptr, len(v))
+		}
+		testUnmarshalErr(v98v2, bs98, h, t, "dec-map-v98")
+		testDeepEqualErr(v98v1, v98v2, t, "equal-map-v98")
+		bs98, _ = testMarshalErr(&v98v1, h, t, "enc-map-v98-p")
+		v98v2 = nil
+		testUnmarshalErr(&v98v2, bs98, h, t, "dec-map-v98-p")
+		testDeepEqualErr(v98v1, v98v2, t, "equal-map-v98-p")
+	}
+
+	for _, v := range []map[uint8]int{nil, map[uint8]int{}, map[uint8]int{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v99: %v\n", v)
+		var v99v1, v99v2 map[uint8]int
+		v99v1 = v
+		bs99, _ := testMarshalErr(v99v1, h, t, "enc-map-v99")
+		if v != nil {
+			v99v2 = make(map[uint8]int, len(v))
+		}
+		testUnmarshalErr(v99v2, bs99, h, t, "dec-map-v99")
+		testDeepEqualErr(v99v1, v99v2, t, "equal-map-v99")
+		bs99, _ = testMarshalErr(&v99v1, h, t, "enc-map-v99-p")
+		v99v2 = nil
+		testUnmarshalErr(&v99v2, bs99, h, t, "dec-map-v99-p")
+		testDeepEqualErr(v99v1, v99v2, t, "equal-map-v99-p")
+	}
+
+	for _, v := range []map[uint8]int8{nil, map[uint8]int8{}, map[uint8]int8{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v100: %v\n", v)
+		var v100v1, v100v2 map[uint8]int8
+		v100v1 = v
+		bs100, _ := testMarshalErr(v100v1, h, t, "enc-map-v100")
+		if v != nil {
+			v100v2 = make(map[uint8]int8, len(v))
+		}
+		testUnmarshalErr(v100v2, bs100, h, t, "dec-map-v100")
+		testDeepEqualErr(v100v1, v100v2, t, "equal-map-v100")
+		bs100, _ = testMarshalErr(&v100v1, h, t, "enc-map-v100-p")
+		v100v2 = nil
+		testUnmarshalErr(&v100v2, bs100, h, t, "dec-map-v100-p")
+		testDeepEqualErr(v100v1, v100v2, t, "equal-map-v100-p")
+	}
+
+	for _, v := range []map[uint8]int16{nil, map[uint8]int16{}, map[uint8]int16{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v101: %v\n", v)
+		var v101v1, v101v2 map[uint8]int16
+		v101v1 = v
+		bs101, _ := testMarshalErr(v101v1, h, t, "enc-map-v101")
+		if v != nil {
+			v101v2 = make(map[uint8]int16, len(v))
+		}
+		testUnmarshalErr(v101v2, bs101, h, t, "dec-map-v101")
+		testDeepEqualErr(v101v1, v101v2, t, "equal-map-v101")
+		bs101, _ = testMarshalErr(&v101v1, h, t, "enc-map-v101-p")
+		v101v2 = nil
+		testUnmarshalErr(&v101v2, bs101, h, t, "dec-map-v101-p")
+		testDeepEqualErr(v101v1, v101v2, t, "equal-map-v101-p")
+	}
+
+	for _, v := range []map[uint8]int32{nil, map[uint8]int32{}, map[uint8]int32{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v102: %v\n", v)
+		var v102v1, v102v2 map[uint8]int32
+		v102v1 = v
+		bs102, _ := testMarshalErr(v102v1, h, t, "enc-map-v102")
+		if v != nil {
+			v102v2 = make(map[uint8]int32, len(v))
+		}
+		testUnmarshalErr(v102v2, bs102, h, t, "dec-map-v102")
+		testDeepEqualErr(v102v1, v102v2, t, "equal-map-v102")
+		bs102, _ = testMarshalErr(&v102v1, h, t, "enc-map-v102-p")
+		v102v2 = nil
+		testUnmarshalErr(&v102v2, bs102, h, t, "dec-map-v102-p")
+		testDeepEqualErr(v102v1, v102v2, t, "equal-map-v102-p")
+	}
+
+	for _, v := range []map[uint8]int64{nil, map[uint8]int64{}, map[uint8]int64{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v103: %v\n", v)
+		var v103v1, v103v2 map[uint8]int64
+		v103v1 = v
+		bs103, _ := testMarshalErr(v103v1, h, t, "enc-map-v103")
+		if v != nil {
+			v103v2 = make(map[uint8]int64, len(v))
+		}
+		testUnmarshalErr(v103v2, bs103, h, t, "dec-map-v103")
+		testDeepEqualErr(v103v1, v103v2, t, "equal-map-v103")
+		bs103, _ = testMarshalErr(&v103v1, h, t, "enc-map-v103-p")
+		v103v2 = nil
+		testUnmarshalErr(&v103v2, bs103, h, t, "dec-map-v103-p")
+		testDeepEqualErr(v103v1, v103v2, t, "equal-map-v103-p")
+	}
+
+	for _, v := range []map[uint8]float32{nil, map[uint8]float32{}, map[uint8]float32{10: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v104: %v\n", v)
+		var v104v1, v104v2 map[uint8]float32
+		v104v1 = v
+		bs104, _ := testMarshalErr(v104v1, h, t, "enc-map-v104")
+		if v != nil {
+			v104v2 = make(map[uint8]float32, len(v))
+		}
+		testUnmarshalErr(v104v2, bs104, h, t, "dec-map-v104")
+		testDeepEqualErr(v104v1, v104v2, t, "equal-map-v104")
+		bs104, _ = testMarshalErr(&v104v1, h, t, "enc-map-v104-p")
+		v104v2 = nil
+		testUnmarshalErr(&v104v2, bs104, h, t, "dec-map-v104-p")
+		testDeepEqualErr(v104v1, v104v2, t, "equal-map-v104-p")
+	}
+
+	for _, v := range []map[uint8]float64{nil, map[uint8]float64{}, map[uint8]float64{10: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v105: %v\n", v)
+		var v105v1, v105v2 map[uint8]float64
+		v105v1 = v
+		bs105, _ := testMarshalErr(v105v1, h, t, "enc-map-v105")
+		if v != nil {
+			v105v2 = make(map[uint8]float64, len(v))
+		}
+		testUnmarshalErr(v105v2, bs105, h, t, "dec-map-v105")
+		testDeepEqualErr(v105v1, v105v2, t, "equal-map-v105")
+		bs105, _ = testMarshalErr(&v105v1, h, t, "enc-map-v105-p")
+		v105v2 = nil
+		testUnmarshalErr(&v105v2, bs105, h, t, "dec-map-v105-p")
+		testDeepEqualErr(v105v1, v105v2, t, "equal-map-v105-p")
+	}
+
+	for _, v := range []map[uint8]bool{nil, map[uint8]bool{}, map[uint8]bool{10: true}} {
+		// fmt.Printf(">>>> running mammoth map v106: %v\n", v)
+		var v106v1, v106v2 map[uint8]bool
+		v106v1 = v
+		bs106, _ := testMarshalErr(v106v1, h, t, "enc-map-v106")
+		if v != nil {
+			v106v2 = make(map[uint8]bool, len(v))
+		}
+		testUnmarshalErr(v106v2, bs106, h, t, "dec-map-v106")
+		testDeepEqualErr(v106v1, v106v2, t, "equal-map-v106")
+		bs106, _ = testMarshalErr(&v106v1, h, t, "enc-map-v106-p")
+		v106v2 = nil
+		testUnmarshalErr(&v106v2, bs106, h, t, "dec-map-v106-p")
+		testDeepEqualErr(v106v1, v106v2, t, "equal-map-v106-p")
+	}
+
+	for _, v := range []map[uint16]interface{}{nil, map[uint16]interface{}{}, map[uint16]interface{}{10: "string-is-an-interface"}} {
+		// fmt.Printf(">>>> running mammoth map v109: %v\n", v)
+		var v109v1, v109v2 map[uint16]interface{}
+		v109v1 = v
+		bs109, _ := testMarshalErr(v109v1, h, t, "enc-map-v109")
+		if v != nil {
+			v109v2 = make(map[uint16]interface{}, len(v))
+		}
+		testUnmarshalErr(v109v2, bs109, h, t, "dec-map-v109")
+		testDeepEqualErr(v109v1, v109v2, t, "equal-map-v109")
+		bs109, _ = testMarshalErr(&v109v1, h, t, "enc-map-v109-p")
+		v109v2 = nil
+		testUnmarshalErr(&v109v2, bs109, h, t, "dec-map-v109-p")
+		testDeepEqualErr(v109v1, v109v2, t, "equal-map-v109-p")
+	}
+
+	for _, v := range []map[uint16]string{nil, map[uint16]string{}, map[uint16]string{10: "some-string"}} {
+		// fmt.Printf(">>>> running mammoth map v110: %v\n", v)
+		var v110v1, v110v2 map[uint16]string
+		v110v1 = v
+		bs110, _ := testMarshalErr(v110v1, h, t, "enc-map-v110")
+		if v != nil {
+			v110v2 = make(map[uint16]string, len(v))
+		}
+		testUnmarshalErr(v110v2, bs110, h, t, "dec-map-v110")
+		testDeepEqualErr(v110v1, v110v2, t, "equal-map-v110")
+		bs110, _ = testMarshalErr(&v110v1, h, t, "enc-map-v110-p")
+		v110v2 = nil
+		testUnmarshalErr(&v110v2, bs110, h, t, "dec-map-v110-p")
+		testDeepEqualErr(v110v1, v110v2, t, "equal-map-v110-p")
+	}
+
+	for _, v := range []map[uint16]uint{nil, map[uint16]uint{}, map[uint16]uint{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v111: %v\n", v)
+		var v111v1, v111v2 map[uint16]uint
+		v111v1 = v
+		bs111, _ := testMarshalErr(v111v1, h, t, "enc-map-v111")
+		if v != nil {
+			v111v2 = make(map[uint16]uint, len(v))
+		}
+		testUnmarshalErr(v111v2, bs111, h, t, "dec-map-v111")
+		testDeepEqualErr(v111v1, v111v2, t, "equal-map-v111")
+		bs111, _ = testMarshalErr(&v111v1, h, t, "enc-map-v111-p")
+		v111v2 = nil
+		testUnmarshalErr(&v111v2, bs111, h, t, "dec-map-v111-p")
+		testDeepEqualErr(v111v1, v111v2, t, "equal-map-v111-p")
+	}
+
+	for _, v := range []map[uint16]uint8{nil, map[uint16]uint8{}, map[uint16]uint8{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v112: %v\n", v)
+		var v112v1, v112v2 map[uint16]uint8
+		v112v1 = v
+		bs112, _ := testMarshalErr(v112v1, h, t, "enc-map-v112")
+		if v != nil {
+			v112v2 = make(map[uint16]uint8, len(v))
+		}
+		testUnmarshalErr(v112v2, bs112, h, t, "dec-map-v112")
+		testDeepEqualErr(v112v1, v112v2, t, "equal-map-v112")
+		bs112, _ = testMarshalErr(&v112v1, h, t, "enc-map-v112-p")
+		v112v2 = nil
+		testUnmarshalErr(&v112v2, bs112, h, t, "dec-map-v112-p")
+		testDeepEqualErr(v112v1, v112v2, t, "equal-map-v112-p")
+	}
+
+	for _, v := range []map[uint16]uint16{nil, map[uint16]uint16{}, map[uint16]uint16{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v113: %v\n", v)
+		var v113v1, v113v2 map[uint16]uint16
+		v113v1 = v
+		bs113, _ := testMarshalErr(v113v1, h, t, "enc-map-v113")
+		if v != nil {
+			v113v2 = make(map[uint16]uint16, len(v))
+		}
+		testUnmarshalErr(v113v2, bs113, h, t, "dec-map-v113")
+		testDeepEqualErr(v113v1, v113v2, t, "equal-map-v113")
+		bs113, _ = testMarshalErr(&v113v1, h, t, "enc-map-v113-p")
+		v113v2 = nil
+		testUnmarshalErr(&v113v2, bs113, h, t, "dec-map-v113-p")
+		testDeepEqualErr(v113v1, v113v2, t, "equal-map-v113-p")
+	}
+
+	for _, v := range []map[uint16]uint32{nil, map[uint16]uint32{}, map[uint16]uint32{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v114: %v\n", v)
+		var v114v1, v114v2 map[uint16]uint32
+		v114v1 = v
+		bs114, _ := testMarshalErr(v114v1, h, t, "enc-map-v114")
+		if v != nil {
+			v114v2 = make(map[uint16]uint32, len(v))
+		}
+		testUnmarshalErr(v114v2, bs114, h, t, "dec-map-v114")
+		testDeepEqualErr(v114v1, v114v2, t, "equal-map-v114")
+		bs114, _ = testMarshalErr(&v114v1, h, t, "enc-map-v114-p")
+		v114v2 = nil
+		testUnmarshalErr(&v114v2, bs114, h, t, "dec-map-v114-p")
+		testDeepEqualErr(v114v1, v114v2, t, "equal-map-v114-p")
+	}
+
+	for _, v := range []map[uint16]uint64{nil, map[uint16]uint64{}, map[uint16]uint64{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v115: %v\n", v)
+		var v115v1, v115v2 map[uint16]uint64
+		v115v1 = v
+		bs115, _ := testMarshalErr(v115v1, h, t, "enc-map-v115")
+		if v != nil {
+			v115v2 = make(map[uint16]uint64, len(v))
+		}
+		testUnmarshalErr(v115v2, bs115, h, t, "dec-map-v115")
+		testDeepEqualErr(v115v1, v115v2, t, "equal-map-v115")
+		bs115, _ = testMarshalErr(&v115v1, h, t, "enc-map-v115-p")
+		v115v2 = nil
+		testUnmarshalErr(&v115v2, bs115, h, t, "dec-map-v115-p")
+		testDeepEqualErr(v115v1, v115v2, t, "equal-map-v115-p")
+	}
+
+	for _, v := range []map[uint16]uintptr{nil, map[uint16]uintptr{}, map[uint16]uintptr{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v116: %v\n", v)
+		var v116v1, v116v2 map[uint16]uintptr
+		v116v1 = v
+		bs116, _ := testMarshalErr(v116v1, h, t, "enc-map-v116")
+		if v != nil {
+			v116v2 = make(map[uint16]uintptr, len(v))
+		}
+		testUnmarshalErr(v116v2, bs116, h, t, "dec-map-v116")
+		testDeepEqualErr(v116v1, v116v2, t, "equal-map-v116")
+		bs116, _ = testMarshalErr(&v116v1, h, t, "enc-map-v116-p")
+		v116v2 = nil
+		testUnmarshalErr(&v116v2, bs116, h, t, "dec-map-v116-p")
+		testDeepEqualErr(v116v1, v116v2, t, "equal-map-v116-p")
+	}
+
+	for _, v := range []map[uint16]int{nil, map[uint16]int{}, map[uint16]int{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v117: %v\n", v)
+		var v117v1, v117v2 map[uint16]int
+		v117v1 = v
+		bs117, _ := testMarshalErr(v117v1, h, t, "enc-map-v117")
+		if v != nil {
+			v117v2 = make(map[uint16]int, len(v))
+		}
+		testUnmarshalErr(v117v2, bs117, h, t, "dec-map-v117")
+		testDeepEqualErr(v117v1, v117v2, t, "equal-map-v117")
+		bs117, _ = testMarshalErr(&v117v1, h, t, "enc-map-v117-p")
+		v117v2 = nil
+		testUnmarshalErr(&v117v2, bs117, h, t, "dec-map-v117-p")
+		testDeepEqualErr(v117v1, v117v2, t, "equal-map-v117-p")
+	}
+
+	for _, v := range []map[uint16]int8{nil, map[uint16]int8{}, map[uint16]int8{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v118: %v\n", v)
+		var v118v1, v118v2 map[uint16]int8
+		v118v1 = v
+		bs118, _ := testMarshalErr(v118v1, h, t, "enc-map-v118")
+		if v != nil {
+			v118v2 = make(map[uint16]int8, len(v))
+		}
+		testUnmarshalErr(v118v2, bs118, h, t, "dec-map-v118")
+		testDeepEqualErr(v118v1, v118v2, t, "equal-map-v118")
+		bs118, _ = testMarshalErr(&v118v1, h, t, "enc-map-v118-p")
+		v118v2 = nil
+		testUnmarshalErr(&v118v2, bs118, h, t, "dec-map-v118-p")
+		testDeepEqualErr(v118v1, v118v2, t, "equal-map-v118-p")
+	}
+
+	for _, v := range []map[uint16]int16{nil, map[uint16]int16{}, map[uint16]int16{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v119: %v\n", v)
+		var v119v1, v119v2 map[uint16]int16
+		v119v1 = v
+		bs119, _ := testMarshalErr(v119v1, h, t, "enc-map-v119")
+		if v != nil {
+			v119v2 = make(map[uint16]int16, len(v))
+		}
+		testUnmarshalErr(v119v2, bs119, h, t, "dec-map-v119")
+		testDeepEqualErr(v119v1, v119v2, t, "equal-map-v119")
+		bs119, _ = testMarshalErr(&v119v1, h, t, "enc-map-v119-p")
+		v119v2 = nil
+		testUnmarshalErr(&v119v2, bs119, h, t, "dec-map-v119-p")
+		testDeepEqualErr(v119v1, v119v2, t, "equal-map-v119-p")
+	}
+
+	for _, v := range []map[uint16]int32{nil, map[uint16]int32{}, map[uint16]int32{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v120: %v\n", v)
+		var v120v1, v120v2 map[uint16]int32
+		v120v1 = v
+		bs120, _ := testMarshalErr(v120v1, h, t, "enc-map-v120")
+		if v != nil {
+			v120v2 = make(map[uint16]int32, len(v))
+		}
+		testUnmarshalErr(v120v2, bs120, h, t, "dec-map-v120")
+		testDeepEqualErr(v120v1, v120v2, t, "equal-map-v120")
+		bs120, _ = testMarshalErr(&v120v1, h, t, "enc-map-v120-p")
+		v120v2 = nil
+		testUnmarshalErr(&v120v2, bs120, h, t, "dec-map-v120-p")
+		testDeepEqualErr(v120v1, v120v2, t, "equal-map-v120-p")
+	}
+
+	for _, v := range []map[uint16]int64{nil, map[uint16]int64{}, map[uint16]int64{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v121: %v\n", v)
+		var v121v1, v121v2 map[uint16]int64
+		v121v1 = v
+		bs121, _ := testMarshalErr(v121v1, h, t, "enc-map-v121")
+		if v != nil {
+			v121v2 = make(map[uint16]int64, len(v))
+		}
+		testUnmarshalErr(v121v2, bs121, h, t, "dec-map-v121")
+		testDeepEqualErr(v121v1, v121v2, t, "equal-map-v121")
+		bs121, _ = testMarshalErr(&v121v1, h, t, "enc-map-v121-p")
+		v121v2 = nil
+		testUnmarshalErr(&v121v2, bs121, h, t, "dec-map-v121-p")
+		testDeepEqualErr(v121v1, v121v2, t, "equal-map-v121-p")
+	}
+
+	for _, v := range []map[uint16]float32{nil, map[uint16]float32{}, map[uint16]float32{10: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v122: %v\n", v)
+		var v122v1, v122v2 map[uint16]float32
+		v122v1 = v
+		bs122, _ := testMarshalErr(v122v1, h, t, "enc-map-v122")
+		if v != nil {
+			v122v2 = make(map[uint16]float32, len(v))
+		}
+		testUnmarshalErr(v122v2, bs122, h, t, "dec-map-v122")
+		testDeepEqualErr(v122v1, v122v2, t, "equal-map-v122")
+		bs122, _ = testMarshalErr(&v122v1, h, t, "enc-map-v122-p")
+		v122v2 = nil
+		testUnmarshalErr(&v122v2, bs122, h, t, "dec-map-v122-p")
+		testDeepEqualErr(v122v1, v122v2, t, "equal-map-v122-p")
+	}
+
+	for _, v := range []map[uint16]float64{nil, map[uint16]float64{}, map[uint16]float64{10: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v123: %v\n", v)
+		var v123v1, v123v2 map[uint16]float64
+		v123v1 = v
+		bs123, _ := testMarshalErr(v123v1, h, t, "enc-map-v123")
+		if v != nil {
+			v123v2 = make(map[uint16]float64, len(v))
+		}
+		testUnmarshalErr(v123v2, bs123, h, t, "dec-map-v123")
+		testDeepEqualErr(v123v1, v123v2, t, "equal-map-v123")
+		bs123, _ = testMarshalErr(&v123v1, h, t, "enc-map-v123-p")
+		v123v2 = nil
+		testUnmarshalErr(&v123v2, bs123, h, t, "dec-map-v123-p")
+		testDeepEqualErr(v123v1, v123v2, t, "equal-map-v123-p")
+	}
+
+	for _, v := range []map[uint16]bool{nil, map[uint16]bool{}, map[uint16]bool{10: true}} {
+		// fmt.Printf(">>>> running mammoth map v124: %v\n", v)
+		var v124v1, v124v2 map[uint16]bool
+		v124v1 = v
+		bs124, _ := testMarshalErr(v124v1, h, t, "enc-map-v124")
+		if v != nil {
+			v124v2 = make(map[uint16]bool, len(v))
+		}
+		testUnmarshalErr(v124v2, bs124, h, t, "dec-map-v124")
+		testDeepEqualErr(v124v1, v124v2, t, "equal-map-v124")
+		bs124, _ = testMarshalErr(&v124v1, h, t, "enc-map-v124-p")
+		v124v2 = nil
+		testUnmarshalErr(&v124v2, bs124, h, t, "dec-map-v124-p")
+		testDeepEqualErr(v124v1, v124v2, t, "equal-map-v124-p")
+	}
+
+	for _, v := range []map[uint32]interface{}{nil, map[uint32]interface{}{}, map[uint32]interface{}{10: "string-is-an-interface"}} {
+		// fmt.Printf(">>>> running mammoth map v127: %v\n", v)
+		var v127v1, v127v2 map[uint32]interface{}
+		v127v1 = v
+		bs127, _ := testMarshalErr(v127v1, h, t, "enc-map-v127")
+		if v != nil {
+			v127v2 = make(map[uint32]interface{}, len(v))
+		}
+		testUnmarshalErr(v127v2, bs127, h, t, "dec-map-v127")
+		testDeepEqualErr(v127v1, v127v2, t, "equal-map-v127")
+		bs127, _ = testMarshalErr(&v127v1, h, t, "enc-map-v127-p")
+		v127v2 = nil
+		testUnmarshalErr(&v127v2, bs127, h, t, "dec-map-v127-p")
+		testDeepEqualErr(v127v1, v127v2, t, "equal-map-v127-p")
+	}
+
+	for _, v := range []map[uint32]string{nil, map[uint32]string{}, map[uint32]string{10: "some-string"}} {
+		// fmt.Printf(">>>> running mammoth map v128: %v\n", v)
+		var v128v1, v128v2 map[uint32]string
+		v128v1 = v
+		bs128, _ := testMarshalErr(v128v1, h, t, "enc-map-v128")
+		if v != nil {
+			v128v2 = make(map[uint32]string, len(v))
+		}
+		testUnmarshalErr(v128v2, bs128, h, t, "dec-map-v128")
+		testDeepEqualErr(v128v1, v128v2, t, "equal-map-v128")
+		bs128, _ = testMarshalErr(&v128v1, h, t, "enc-map-v128-p")
+		v128v2 = nil
+		testUnmarshalErr(&v128v2, bs128, h, t, "dec-map-v128-p")
+		testDeepEqualErr(v128v1, v128v2, t, "equal-map-v128-p")
+	}
+
+	for _, v := range []map[uint32]uint{nil, map[uint32]uint{}, map[uint32]uint{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v129: %v\n", v)
+		var v129v1, v129v2 map[uint32]uint
+		v129v1 = v
+		bs129, _ := testMarshalErr(v129v1, h, t, "enc-map-v129")
+		if v != nil {
+			v129v2 = make(map[uint32]uint, len(v))
+		}
+		testUnmarshalErr(v129v2, bs129, h, t, "dec-map-v129")
+		testDeepEqualErr(v129v1, v129v2, t, "equal-map-v129")
+		bs129, _ = testMarshalErr(&v129v1, h, t, "enc-map-v129-p")
+		v129v2 = nil
+		testUnmarshalErr(&v129v2, bs129, h, t, "dec-map-v129-p")
+		testDeepEqualErr(v129v1, v129v2, t, "equal-map-v129-p")
+	}
+
+	for _, v := range []map[uint32]uint8{nil, map[uint32]uint8{}, map[uint32]uint8{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v130: %v\n", v)
+		var v130v1, v130v2 map[uint32]uint8
+		v130v1 = v
+		bs130, _ := testMarshalErr(v130v1, h, t, "enc-map-v130")
+		if v != nil {
+			v130v2 = make(map[uint32]uint8, len(v))
+		}
+		testUnmarshalErr(v130v2, bs130, h, t, "dec-map-v130")
+		testDeepEqualErr(v130v1, v130v2, t, "equal-map-v130")
+		bs130, _ = testMarshalErr(&v130v1, h, t, "enc-map-v130-p")
+		v130v2 = nil
+		testUnmarshalErr(&v130v2, bs130, h, t, "dec-map-v130-p")
+		testDeepEqualErr(v130v1, v130v2, t, "equal-map-v130-p")
+	}
+
+	for _, v := range []map[uint32]uint16{nil, map[uint32]uint16{}, map[uint32]uint16{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v131: %v\n", v)
+		var v131v1, v131v2 map[uint32]uint16
+		v131v1 = v
+		bs131, _ := testMarshalErr(v131v1, h, t, "enc-map-v131")
+		if v != nil {
+			v131v2 = make(map[uint32]uint16, len(v))
+		}
+		testUnmarshalErr(v131v2, bs131, h, t, "dec-map-v131")
+		testDeepEqualErr(v131v1, v131v2, t, "equal-map-v131")
+		bs131, _ = testMarshalErr(&v131v1, h, t, "enc-map-v131-p")
+		v131v2 = nil
+		testUnmarshalErr(&v131v2, bs131, h, t, "dec-map-v131-p")
+		testDeepEqualErr(v131v1, v131v2, t, "equal-map-v131-p")
+	}
+
+	for _, v := range []map[uint32]uint32{nil, map[uint32]uint32{}, map[uint32]uint32{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v132: %v\n", v)
+		var v132v1, v132v2 map[uint32]uint32
+		v132v1 = v
+		bs132, _ := testMarshalErr(v132v1, h, t, "enc-map-v132")
+		if v != nil {
+			v132v2 = make(map[uint32]uint32, len(v))
+		}
+		testUnmarshalErr(v132v2, bs132, h, t, "dec-map-v132")
+		testDeepEqualErr(v132v1, v132v2, t, "equal-map-v132")
+		bs132, _ = testMarshalErr(&v132v1, h, t, "enc-map-v132-p")
+		v132v2 = nil
+		testUnmarshalErr(&v132v2, bs132, h, t, "dec-map-v132-p")
+		testDeepEqualErr(v132v1, v132v2, t, "equal-map-v132-p")
+	}
+
+	for _, v := range []map[uint32]uint64{nil, map[uint32]uint64{}, map[uint32]uint64{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v133: %v\n", v)
+		var v133v1, v133v2 map[uint32]uint64
+		v133v1 = v
+		bs133, _ := testMarshalErr(v133v1, h, t, "enc-map-v133")
+		if v != nil {
+			v133v2 = make(map[uint32]uint64, len(v))
+		}
+		testUnmarshalErr(v133v2, bs133, h, t, "dec-map-v133")
+		testDeepEqualErr(v133v1, v133v2, t, "equal-map-v133")
+		bs133, _ = testMarshalErr(&v133v1, h, t, "enc-map-v133-p")
+		v133v2 = nil
+		testUnmarshalErr(&v133v2, bs133, h, t, "dec-map-v133-p")
+		testDeepEqualErr(v133v1, v133v2, t, "equal-map-v133-p")
+	}
+
+	for _, v := range []map[uint32]uintptr{nil, map[uint32]uintptr{}, map[uint32]uintptr{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v134: %v\n", v)
+		var v134v1, v134v2 map[uint32]uintptr
+		v134v1 = v
+		bs134, _ := testMarshalErr(v134v1, h, t, "enc-map-v134")
+		if v != nil {
+			v134v2 = make(map[uint32]uintptr, len(v))
+		}
+		testUnmarshalErr(v134v2, bs134, h, t, "dec-map-v134")
+		testDeepEqualErr(v134v1, v134v2, t, "equal-map-v134")
+		bs134, _ = testMarshalErr(&v134v1, h, t, "enc-map-v134-p")
+		v134v2 = nil
+		testUnmarshalErr(&v134v2, bs134, h, t, "dec-map-v134-p")
+		testDeepEqualErr(v134v1, v134v2, t, "equal-map-v134-p")
+	}
+
+	for _, v := range []map[uint32]int{nil, map[uint32]int{}, map[uint32]int{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v135: %v\n", v)
+		var v135v1, v135v2 map[uint32]int
+		v135v1 = v
+		bs135, _ := testMarshalErr(v135v1, h, t, "enc-map-v135")
+		if v != nil {
+			v135v2 = make(map[uint32]int, len(v))
+		}
+		testUnmarshalErr(v135v2, bs135, h, t, "dec-map-v135")
+		testDeepEqualErr(v135v1, v135v2, t, "equal-map-v135")
+		bs135, _ = testMarshalErr(&v135v1, h, t, "enc-map-v135-p")
+		v135v2 = nil
+		testUnmarshalErr(&v135v2, bs135, h, t, "dec-map-v135-p")
+		testDeepEqualErr(v135v1, v135v2, t, "equal-map-v135-p")
+	}
+
+	for _, v := range []map[uint32]int8{nil, map[uint32]int8{}, map[uint32]int8{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v136: %v\n", v)
+		var v136v1, v136v2 map[uint32]int8
+		v136v1 = v
+		bs136, _ := testMarshalErr(v136v1, h, t, "enc-map-v136")
+		if v != nil {
+			v136v2 = make(map[uint32]int8, len(v))
+		}
+		testUnmarshalErr(v136v2, bs136, h, t, "dec-map-v136")
+		testDeepEqualErr(v136v1, v136v2, t, "equal-map-v136")
+		bs136, _ = testMarshalErr(&v136v1, h, t, "enc-map-v136-p")
+		v136v2 = nil
+		testUnmarshalErr(&v136v2, bs136, h, t, "dec-map-v136-p")
+		testDeepEqualErr(v136v1, v136v2, t, "equal-map-v136-p")
+	}
+
+	for _, v := range []map[uint32]int16{nil, map[uint32]int16{}, map[uint32]int16{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v137: %v\n", v)
+		var v137v1, v137v2 map[uint32]int16
+		v137v1 = v
+		bs137, _ := testMarshalErr(v137v1, h, t, "enc-map-v137")
+		if v != nil {
+			v137v2 = make(map[uint32]int16, len(v))
+		}
+		testUnmarshalErr(v137v2, bs137, h, t, "dec-map-v137")
+		testDeepEqualErr(v137v1, v137v2, t, "equal-map-v137")
+		bs137, _ = testMarshalErr(&v137v1, h, t, "enc-map-v137-p")
+		v137v2 = nil
+		testUnmarshalErr(&v137v2, bs137, h, t, "dec-map-v137-p")
+		testDeepEqualErr(v137v1, v137v2, t, "equal-map-v137-p")
+	}
+
+	for _, v := range []map[uint32]int32{nil, map[uint32]int32{}, map[uint32]int32{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v138: %v\n", v)
+		var v138v1, v138v2 map[uint32]int32
+		v138v1 = v
+		bs138, _ := testMarshalErr(v138v1, h, t, "enc-map-v138")
+		if v != nil {
+			v138v2 = make(map[uint32]int32, len(v))
+		}
+		testUnmarshalErr(v138v2, bs138, h, t, "dec-map-v138")
+		testDeepEqualErr(v138v1, v138v2, t, "equal-map-v138")
+		bs138, _ = testMarshalErr(&v138v1, h, t, "enc-map-v138-p")
+		v138v2 = nil
+		testUnmarshalErr(&v138v2, bs138, h, t, "dec-map-v138-p")
+		testDeepEqualErr(v138v1, v138v2, t, "equal-map-v138-p")
+	}
+
+	for _, v := range []map[uint32]int64{nil, map[uint32]int64{}, map[uint32]int64{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v139: %v\n", v)
+		var v139v1, v139v2 map[uint32]int64
+		v139v1 = v
+		bs139, _ := testMarshalErr(v139v1, h, t, "enc-map-v139")
+		if v != nil {
+			v139v2 = make(map[uint32]int64, len(v))
+		}
+		testUnmarshalErr(v139v2, bs139, h, t, "dec-map-v139")
+		testDeepEqualErr(v139v1, v139v2, t, "equal-map-v139")
+		bs139, _ = testMarshalErr(&v139v1, h, t, "enc-map-v139-p")
+		v139v2 = nil
+		testUnmarshalErr(&v139v2, bs139, h, t, "dec-map-v139-p")
+		testDeepEqualErr(v139v1, v139v2, t, "equal-map-v139-p")
+	}
+
+	for _, v := range []map[uint32]float32{nil, map[uint32]float32{}, map[uint32]float32{10: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v140: %v\n", v)
+		var v140v1, v140v2 map[uint32]float32
+		v140v1 = v
+		bs140, _ := testMarshalErr(v140v1, h, t, "enc-map-v140")
+		if v != nil {
+			v140v2 = make(map[uint32]float32, len(v))
+		}
+		testUnmarshalErr(v140v2, bs140, h, t, "dec-map-v140")
+		testDeepEqualErr(v140v1, v140v2, t, "equal-map-v140")
+		bs140, _ = testMarshalErr(&v140v1, h, t, "enc-map-v140-p")
+		v140v2 = nil
+		testUnmarshalErr(&v140v2, bs140, h, t, "dec-map-v140-p")
+		testDeepEqualErr(v140v1, v140v2, t, "equal-map-v140-p")
+	}
+
+	for _, v := range []map[uint32]float64{nil, map[uint32]float64{}, map[uint32]float64{10: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v141: %v\n", v)
+		var v141v1, v141v2 map[uint32]float64
+		v141v1 = v
+		bs141, _ := testMarshalErr(v141v1, h, t, "enc-map-v141")
+		if v != nil {
+			v141v2 = make(map[uint32]float64, len(v))
+		}
+		testUnmarshalErr(v141v2, bs141, h, t, "dec-map-v141")
+		testDeepEqualErr(v141v1, v141v2, t, "equal-map-v141")
+		bs141, _ = testMarshalErr(&v141v1, h, t, "enc-map-v141-p")
+		v141v2 = nil
+		testUnmarshalErr(&v141v2, bs141, h, t, "dec-map-v141-p")
+		testDeepEqualErr(v141v1, v141v2, t, "equal-map-v141-p")
+	}
+
+	for _, v := range []map[uint32]bool{nil, map[uint32]bool{}, map[uint32]bool{10: true}} {
+		// fmt.Printf(">>>> running mammoth map v142: %v\n", v)
+		var v142v1, v142v2 map[uint32]bool
+		v142v1 = v
+		bs142, _ := testMarshalErr(v142v1, h, t, "enc-map-v142")
+		if v != nil {
+			v142v2 = make(map[uint32]bool, len(v))
+		}
+		testUnmarshalErr(v142v2, bs142, h, t, "dec-map-v142")
+		testDeepEqualErr(v142v1, v142v2, t, "equal-map-v142")
+		bs142, _ = testMarshalErr(&v142v1, h, t, "enc-map-v142-p")
+		v142v2 = nil
+		testUnmarshalErr(&v142v2, bs142, h, t, "dec-map-v142-p")
+		testDeepEqualErr(v142v1, v142v2, t, "equal-map-v142-p")
+	}
+
+	for _, v := range []map[uint64]interface{}{nil, map[uint64]interface{}{}, map[uint64]interface{}{10: "string-is-an-interface"}} {
+		// fmt.Printf(">>>> running mammoth map v145: %v\n", v)
+		var v145v1, v145v2 map[uint64]interface{}
+		v145v1 = v
+		bs145, _ := testMarshalErr(v145v1, h, t, "enc-map-v145")
+		if v != nil {
+			v145v2 = make(map[uint64]interface{}, len(v))
+		}
+		testUnmarshalErr(v145v2, bs145, h, t, "dec-map-v145")
+		testDeepEqualErr(v145v1, v145v2, t, "equal-map-v145")
+		bs145, _ = testMarshalErr(&v145v1, h, t, "enc-map-v145-p")
+		v145v2 = nil
+		testUnmarshalErr(&v145v2, bs145, h, t, "dec-map-v145-p")
+		testDeepEqualErr(v145v1, v145v2, t, "equal-map-v145-p")
+	}
+
+	for _, v := range []map[uint64]string{nil, map[uint64]string{}, map[uint64]string{10: "some-string"}} {
+		// fmt.Printf(">>>> running mammoth map v146: %v\n", v)
+		var v146v1, v146v2 map[uint64]string
+		v146v1 = v
+		bs146, _ := testMarshalErr(v146v1, h, t, "enc-map-v146")
+		if v != nil {
+			v146v2 = make(map[uint64]string, len(v))
+		}
+		testUnmarshalErr(v146v2, bs146, h, t, "dec-map-v146")
+		testDeepEqualErr(v146v1, v146v2, t, "equal-map-v146")
+		bs146, _ = testMarshalErr(&v146v1, h, t, "enc-map-v146-p")
+		v146v2 = nil
+		testUnmarshalErr(&v146v2, bs146, h, t, "dec-map-v146-p")
+		testDeepEqualErr(v146v1, v146v2, t, "equal-map-v146-p")
+	}
+
+	for _, v := range []map[uint64]uint{nil, map[uint64]uint{}, map[uint64]uint{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v147: %v\n", v)
+		var v147v1, v147v2 map[uint64]uint
+		v147v1 = v
+		bs147, _ := testMarshalErr(v147v1, h, t, "enc-map-v147")
+		if v != nil {
+			v147v2 = make(map[uint64]uint, len(v))
+		}
+		testUnmarshalErr(v147v2, bs147, h, t, "dec-map-v147")
+		testDeepEqualErr(v147v1, v147v2, t, "equal-map-v147")
+		bs147, _ = testMarshalErr(&v147v1, h, t, "enc-map-v147-p")
+		v147v2 = nil
+		testUnmarshalErr(&v147v2, bs147, h, t, "dec-map-v147-p")
+		testDeepEqualErr(v147v1, v147v2, t, "equal-map-v147-p")
+	}
+
+	for _, v := range []map[uint64]uint8{nil, map[uint64]uint8{}, map[uint64]uint8{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v148: %v\n", v)
+		var v148v1, v148v2 map[uint64]uint8
+		v148v1 = v
+		bs148, _ := testMarshalErr(v148v1, h, t, "enc-map-v148")
+		if v != nil {
+			v148v2 = make(map[uint64]uint8, len(v))
+		}
+		testUnmarshalErr(v148v2, bs148, h, t, "dec-map-v148")
+		testDeepEqualErr(v148v1, v148v2, t, "equal-map-v148")
+		bs148, _ = testMarshalErr(&v148v1, h, t, "enc-map-v148-p")
+		v148v2 = nil
+		testUnmarshalErr(&v148v2, bs148, h, t, "dec-map-v148-p")
+		testDeepEqualErr(v148v1, v148v2, t, "equal-map-v148-p")
+	}
+
+	for _, v := range []map[uint64]uint16{nil, map[uint64]uint16{}, map[uint64]uint16{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v149: %v\n", v)
+		var v149v1, v149v2 map[uint64]uint16
+		v149v1 = v
+		bs149, _ := testMarshalErr(v149v1, h, t, "enc-map-v149")
+		if v != nil {
+			v149v2 = make(map[uint64]uint16, len(v))
+		}
+		testUnmarshalErr(v149v2, bs149, h, t, "dec-map-v149")
+		testDeepEqualErr(v149v1, v149v2, t, "equal-map-v149")
+		bs149, _ = testMarshalErr(&v149v1, h, t, "enc-map-v149-p")
+		v149v2 = nil
+		testUnmarshalErr(&v149v2, bs149, h, t, "dec-map-v149-p")
+		testDeepEqualErr(v149v1, v149v2, t, "equal-map-v149-p")
+	}
+
+	for _, v := range []map[uint64]uint32{nil, map[uint64]uint32{}, map[uint64]uint32{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v150: %v\n", v)
+		var v150v1, v150v2 map[uint64]uint32
+		v150v1 = v
+		bs150, _ := testMarshalErr(v150v1, h, t, "enc-map-v150")
+		if v != nil {
+			v150v2 = make(map[uint64]uint32, len(v))
+		}
+		testUnmarshalErr(v150v2, bs150, h, t, "dec-map-v150")
+		testDeepEqualErr(v150v1, v150v2, t, "equal-map-v150")
+		bs150, _ = testMarshalErr(&v150v1, h, t, "enc-map-v150-p")
+		v150v2 = nil
+		testUnmarshalErr(&v150v2, bs150, h, t, "dec-map-v150-p")
+		testDeepEqualErr(v150v1, v150v2, t, "equal-map-v150-p")
+	}
+
+	for _, v := range []map[uint64]uint64{nil, map[uint64]uint64{}, map[uint64]uint64{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v151: %v\n", v)
+		var v151v1, v151v2 map[uint64]uint64
+		v151v1 = v
+		bs151, _ := testMarshalErr(v151v1, h, t, "enc-map-v151")
+		if v != nil {
+			v151v2 = make(map[uint64]uint64, len(v))
+		}
+		testUnmarshalErr(v151v2, bs151, h, t, "dec-map-v151")
+		testDeepEqualErr(v151v1, v151v2, t, "equal-map-v151")
+		bs151, _ = testMarshalErr(&v151v1, h, t, "enc-map-v151-p")
+		v151v2 = nil
+		testUnmarshalErr(&v151v2, bs151, h, t, "dec-map-v151-p")
+		testDeepEqualErr(v151v1, v151v2, t, "equal-map-v151-p")
+	}
+
+	for _, v := range []map[uint64]uintptr{nil, map[uint64]uintptr{}, map[uint64]uintptr{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v152: %v\n", v)
+		var v152v1, v152v2 map[uint64]uintptr
+		v152v1 = v
+		bs152, _ := testMarshalErr(v152v1, h, t, "enc-map-v152")
+		if v != nil {
+			v152v2 = make(map[uint64]uintptr, len(v))
+		}
+		testUnmarshalErr(v152v2, bs152, h, t, "dec-map-v152")
+		testDeepEqualErr(v152v1, v152v2, t, "equal-map-v152")
+		bs152, _ = testMarshalErr(&v152v1, h, t, "enc-map-v152-p")
+		v152v2 = nil
+		testUnmarshalErr(&v152v2, bs152, h, t, "dec-map-v152-p")
+		testDeepEqualErr(v152v1, v152v2, t, "equal-map-v152-p")
+	}
+
+	for _, v := range []map[uint64]int{nil, map[uint64]int{}, map[uint64]int{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v153: %v\n", v)
+		var v153v1, v153v2 map[uint64]int
+		v153v1 = v
+		bs153, _ := testMarshalErr(v153v1, h, t, "enc-map-v153")
+		if v != nil {
+			v153v2 = make(map[uint64]int, len(v))
+		}
+		testUnmarshalErr(v153v2, bs153, h, t, "dec-map-v153")
+		testDeepEqualErr(v153v1, v153v2, t, "equal-map-v153")
+		bs153, _ = testMarshalErr(&v153v1, h, t, "enc-map-v153-p")
+		v153v2 = nil
+		testUnmarshalErr(&v153v2, bs153, h, t, "dec-map-v153-p")
+		testDeepEqualErr(v153v1, v153v2, t, "equal-map-v153-p")
+	}
+
+	for _, v := range []map[uint64]int8{nil, map[uint64]int8{}, map[uint64]int8{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v154: %v\n", v)
+		var v154v1, v154v2 map[uint64]int8
+		v154v1 = v
+		bs154, _ := testMarshalErr(v154v1, h, t, "enc-map-v154")
+		if v != nil {
+			v154v2 = make(map[uint64]int8, len(v))
+		}
+		testUnmarshalErr(v154v2, bs154, h, t, "dec-map-v154")
+		testDeepEqualErr(v154v1, v154v2, t, "equal-map-v154")
+		bs154, _ = testMarshalErr(&v154v1, h, t, "enc-map-v154-p")
+		v154v2 = nil
+		testUnmarshalErr(&v154v2, bs154, h, t, "dec-map-v154-p")
+		testDeepEqualErr(v154v1, v154v2, t, "equal-map-v154-p")
+	}
+
+	for _, v := range []map[uint64]int16{nil, map[uint64]int16{}, map[uint64]int16{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v155: %v\n", v)
+		var v155v1, v155v2 map[uint64]int16
+		v155v1 = v
+		bs155, _ := testMarshalErr(v155v1, h, t, "enc-map-v155")
+		if v != nil {
+			v155v2 = make(map[uint64]int16, len(v))
+		}
+		testUnmarshalErr(v155v2, bs155, h, t, "dec-map-v155")
+		testDeepEqualErr(v155v1, v155v2, t, "equal-map-v155")
+		bs155, _ = testMarshalErr(&v155v1, h, t, "enc-map-v155-p")
+		v155v2 = nil
+		testUnmarshalErr(&v155v2, bs155, h, t, "dec-map-v155-p")
+		testDeepEqualErr(v155v1, v155v2, t, "equal-map-v155-p")
+	}
+
+	for _, v := range []map[uint64]int32{nil, map[uint64]int32{}, map[uint64]int32{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v156: %v\n", v)
+		var v156v1, v156v2 map[uint64]int32
+		v156v1 = v
+		bs156, _ := testMarshalErr(v156v1, h, t, "enc-map-v156")
+		if v != nil {
+			v156v2 = make(map[uint64]int32, len(v))
+		}
+		testUnmarshalErr(v156v2, bs156, h, t, "dec-map-v156")
+		testDeepEqualErr(v156v1, v156v2, t, "equal-map-v156")
+		bs156, _ = testMarshalErr(&v156v1, h, t, "enc-map-v156-p")
+		v156v2 = nil
+		testUnmarshalErr(&v156v2, bs156, h, t, "dec-map-v156-p")
+		testDeepEqualErr(v156v1, v156v2, t, "equal-map-v156-p")
+	}
+
+	for _, v := range []map[uint64]int64{nil, map[uint64]int64{}, map[uint64]int64{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v157: %v\n", v)
+		var v157v1, v157v2 map[uint64]int64
+		v157v1 = v
+		bs157, _ := testMarshalErr(v157v1, h, t, "enc-map-v157")
+		if v != nil {
+			v157v2 = make(map[uint64]int64, len(v))
+		}
+		testUnmarshalErr(v157v2, bs157, h, t, "dec-map-v157")
+		testDeepEqualErr(v157v1, v157v2, t, "equal-map-v157")
+		bs157, _ = testMarshalErr(&v157v1, h, t, "enc-map-v157-p")
+		v157v2 = nil
+		testUnmarshalErr(&v157v2, bs157, h, t, "dec-map-v157-p")
+		testDeepEqualErr(v157v1, v157v2, t, "equal-map-v157-p")
+	}
+
+	for _, v := range []map[uint64]float32{nil, map[uint64]float32{}, map[uint64]float32{10: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v158: %v\n", v)
+		var v158v1, v158v2 map[uint64]float32
+		v158v1 = v
+		bs158, _ := testMarshalErr(v158v1, h, t, "enc-map-v158")
+		if v != nil {
+			v158v2 = make(map[uint64]float32, len(v))
+		}
+		testUnmarshalErr(v158v2, bs158, h, t, "dec-map-v158")
+		testDeepEqualErr(v158v1, v158v2, t, "equal-map-v158")
+		bs158, _ = testMarshalErr(&v158v1, h, t, "enc-map-v158-p")
+		v158v2 = nil
+		testUnmarshalErr(&v158v2, bs158, h, t, "dec-map-v158-p")
+		testDeepEqualErr(v158v1, v158v2, t, "equal-map-v158-p")
+	}
+
+	for _, v := range []map[uint64]float64{nil, map[uint64]float64{}, map[uint64]float64{10: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v159: %v\n", v)
+		var v159v1, v159v2 map[uint64]float64
+		v159v1 = v
+		bs159, _ := testMarshalErr(v159v1, h, t, "enc-map-v159")
+		if v != nil {
+			v159v2 = make(map[uint64]float64, len(v))
+		}
+		testUnmarshalErr(v159v2, bs159, h, t, "dec-map-v159")
+		testDeepEqualErr(v159v1, v159v2, t, "equal-map-v159")
+		bs159, _ = testMarshalErr(&v159v1, h, t, "enc-map-v159-p")
+		v159v2 = nil
+		testUnmarshalErr(&v159v2, bs159, h, t, "dec-map-v159-p")
+		testDeepEqualErr(v159v1, v159v2, t, "equal-map-v159-p")
+	}
+
+	for _, v := range []map[uint64]bool{nil, map[uint64]bool{}, map[uint64]bool{10: true}} {
+		// fmt.Printf(">>>> running mammoth map v160: %v\n", v)
+		var v160v1, v160v2 map[uint64]bool
+		v160v1 = v
+		bs160, _ := testMarshalErr(v160v1, h, t, "enc-map-v160")
+		if v != nil {
+			v160v2 = make(map[uint64]bool, len(v))
+		}
+		testUnmarshalErr(v160v2, bs160, h, t, "dec-map-v160")
+		testDeepEqualErr(v160v1, v160v2, t, "equal-map-v160")
+		bs160, _ = testMarshalErr(&v160v1, h, t, "enc-map-v160-p")
+		v160v2 = nil
+		testUnmarshalErr(&v160v2, bs160, h, t, "dec-map-v160-p")
+		testDeepEqualErr(v160v1, v160v2, t, "equal-map-v160-p")
+	}
+
+	for _, v := range []map[uintptr]interface{}{nil, map[uintptr]interface{}{}, map[uintptr]interface{}{10: "string-is-an-interface"}} {
+		// fmt.Printf(">>>> running mammoth map v163: %v\n", v)
+		var v163v1, v163v2 map[uintptr]interface{}
+		v163v1 = v
+		bs163, _ := testMarshalErr(v163v1, h, t, "enc-map-v163")
+		if v != nil {
+			v163v2 = make(map[uintptr]interface{}, len(v))
+		}
+		testUnmarshalErr(v163v2, bs163, h, t, "dec-map-v163")
+		testDeepEqualErr(v163v1, v163v2, t, "equal-map-v163")
+		bs163, _ = testMarshalErr(&v163v1, h, t, "enc-map-v163-p")
+		v163v2 = nil
+		testUnmarshalErr(&v163v2, bs163, h, t, "dec-map-v163-p")
+		testDeepEqualErr(v163v1, v163v2, t, "equal-map-v163-p")
+	}
+
+	for _, v := range []map[uintptr]string{nil, map[uintptr]string{}, map[uintptr]string{10: "some-string"}} {
+		// fmt.Printf(">>>> running mammoth map v164: %v\n", v)
+		var v164v1, v164v2 map[uintptr]string
+		v164v1 = v
+		bs164, _ := testMarshalErr(v164v1, h, t, "enc-map-v164")
+		if v != nil {
+			v164v2 = make(map[uintptr]string, len(v))
+		}
+		testUnmarshalErr(v164v2, bs164, h, t, "dec-map-v164")
+		testDeepEqualErr(v164v1, v164v2, t, "equal-map-v164")
+		bs164, _ = testMarshalErr(&v164v1, h, t, "enc-map-v164-p")
+		v164v2 = nil
+		testUnmarshalErr(&v164v2, bs164, h, t, "dec-map-v164-p")
+		testDeepEqualErr(v164v1, v164v2, t, "equal-map-v164-p")
+	}
+
+	for _, v := range []map[uintptr]uint{nil, map[uintptr]uint{}, map[uintptr]uint{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v165: %v\n", v)
+		var v165v1, v165v2 map[uintptr]uint
+		v165v1 = v
+		bs165, _ := testMarshalErr(v165v1, h, t, "enc-map-v165")
+		if v != nil {
+			v165v2 = make(map[uintptr]uint, len(v))
+		}
+		testUnmarshalErr(v165v2, bs165, h, t, "dec-map-v165")
+		testDeepEqualErr(v165v1, v165v2, t, "equal-map-v165")
+		bs165, _ = testMarshalErr(&v165v1, h, t, "enc-map-v165-p")
+		v165v2 = nil
+		testUnmarshalErr(&v165v2, bs165, h, t, "dec-map-v165-p")
+		testDeepEqualErr(v165v1, v165v2, t, "equal-map-v165-p")
+	}
+
+	for _, v := range []map[uintptr]uint8{nil, map[uintptr]uint8{}, map[uintptr]uint8{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v166: %v\n", v)
+		var v166v1, v166v2 map[uintptr]uint8
+		v166v1 = v
+		bs166, _ := testMarshalErr(v166v1, h, t, "enc-map-v166")
+		if v != nil {
+			v166v2 = make(map[uintptr]uint8, len(v))
+		}
+		testUnmarshalErr(v166v2, bs166, h, t, "dec-map-v166")
+		testDeepEqualErr(v166v1, v166v2, t, "equal-map-v166")
+		bs166, _ = testMarshalErr(&v166v1, h, t, "enc-map-v166-p")
+		v166v2 = nil
+		testUnmarshalErr(&v166v2, bs166, h, t, "dec-map-v166-p")
+		testDeepEqualErr(v166v1, v166v2, t, "equal-map-v166-p")
+	}
+
+	for _, v := range []map[uintptr]uint16{nil, map[uintptr]uint16{}, map[uintptr]uint16{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v167: %v\n", v)
+		var v167v1, v167v2 map[uintptr]uint16
+		v167v1 = v
+		bs167, _ := testMarshalErr(v167v1, h, t, "enc-map-v167")
+		if v != nil {
+			v167v2 = make(map[uintptr]uint16, len(v))
+		}
+		testUnmarshalErr(v167v2, bs167, h, t, "dec-map-v167")
+		testDeepEqualErr(v167v1, v167v2, t, "equal-map-v167")
+		bs167, _ = testMarshalErr(&v167v1, h, t, "enc-map-v167-p")
+		v167v2 = nil
+		testUnmarshalErr(&v167v2, bs167, h, t, "dec-map-v167-p")
+		testDeepEqualErr(v167v1, v167v2, t, "equal-map-v167-p")
+	}
+
+	for _, v := range []map[uintptr]uint32{nil, map[uintptr]uint32{}, map[uintptr]uint32{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v168: %v\n", v)
+		var v168v1, v168v2 map[uintptr]uint32
+		v168v1 = v
+		bs168, _ := testMarshalErr(v168v1, h, t, "enc-map-v168")
+		if v != nil {
+			v168v2 = make(map[uintptr]uint32, len(v))
+		}
+		testUnmarshalErr(v168v2, bs168, h, t, "dec-map-v168")
+		testDeepEqualErr(v168v1, v168v2, t, "equal-map-v168")
+		bs168, _ = testMarshalErr(&v168v1, h, t, "enc-map-v168-p")
+		v168v2 = nil
+		testUnmarshalErr(&v168v2, bs168, h, t, "dec-map-v168-p")
+		testDeepEqualErr(v168v1, v168v2, t, "equal-map-v168-p")
+	}
+
+	for _, v := range []map[uintptr]uint64{nil, map[uintptr]uint64{}, map[uintptr]uint64{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v169: %v\n", v)
+		var v169v1, v169v2 map[uintptr]uint64
+		v169v1 = v
+		bs169, _ := testMarshalErr(v169v1, h, t, "enc-map-v169")
+		if v != nil {
+			v169v2 = make(map[uintptr]uint64, len(v))
+		}
+		testUnmarshalErr(v169v2, bs169, h, t, "dec-map-v169")
+		testDeepEqualErr(v169v1, v169v2, t, "equal-map-v169")
+		bs169, _ = testMarshalErr(&v169v1, h, t, "enc-map-v169-p")
+		v169v2 = nil
+		testUnmarshalErr(&v169v2, bs169, h, t, "dec-map-v169-p")
+		testDeepEqualErr(v169v1, v169v2, t, "equal-map-v169-p")
+	}
+
+	for _, v := range []map[uintptr]uintptr{nil, map[uintptr]uintptr{}, map[uintptr]uintptr{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v170: %v\n", v)
+		var v170v1, v170v2 map[uintptr]uintptr
+		v170v1 = v
+		bs170, _ := testMarshalErr(v170v1, h, t, "enc-map-v170")
+		if v != nil {
+			v170v2 = make(map[uintptr]uintptr, len(v))
+		}
+		testUnmarshalErr(v170v2, bs170, h, t, "dec-map-v170")
+		testDeepEqualErr(v170v1, v170v2, t, "equal-map-v170")
+		bs170, _ = testMarshalErr(&v170v1, h, t, "enc-map-v170-p")
+		v170v2 = nil
+		testUnmarshalErr(&v170v2, bs170, h, t, "dec-map-v170-p")
+		testDeepEqualErr(v170v1, v170v2, t, "equal-map-v170-p")
+	}
+
+	for _, v := range []map[uintptr]int{nil, map[uintptr]int{}, map[uintptr]int{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v171: %v\n", v)
+		var v171v1, v171v2 map[uintptr]int
+		v171v1 = v
+		bs171, _ := testMarshalErr(v171v1, h, t, "enc-map-v171")
+		if v != nil {
+			v171v2 = make(map[uintptr]int, len(v))
+		}
+		testUnmarshalErr(v171v2, bs171, h, t, "dec-map-v171")
+		testDeepEqualErr(v171v1, v171v2, t, "equal-map-v171")
+		bs171, _ = testMarshalErr(&v171v1, h, t, "enc-map-v171-p")
+		v171v2 = nil
+		testUnmarshalErr(&v171v2, bs171, h, t, "dec-map-v171-p")
+		testDeepEqualErr(v171v1, v171v2, t, "equal-map-v171-p")
+	}
+
+	for _, v := range []map[uintptr]int8{nil, map[uintptr]int8{}, map[uintptr]int8{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v172: %v\n", v)
+		var v172v1, v172v2 map[uintptr]int8
+		v172v1 = v
+		bs172, _ := testMarshalErr(v172v1, h, t, "enc-map-v172")
+		if v != nil {
+			v172v2 = make(map[uintptr]int8, len(v))
+		}
+		testUnmarshalErr(v172v2, bs172, h, t, "dec-map-v172")
+		testDeepEqualErr(v172v1, v172v2, t, "equal-map-v172")
+		bs172, _ = testMarshalErr(&v172v1, h, t, "enc-map-v172-p")
+		v172v2 = nil
+		testUnmarshalErr(&v172v2, bs172, h, t, "dec-map-v172-p")
+		testDeepEqualErr(v172v1, v172v2, t, "equal-map-v172-p")
+	}
+
+	for _, v := range []map[uintptr]int16{nil, map[uintptr]int16{}, map[uintptr]int16{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v173: %v\n", v)
+		var v173v1, v173v2 map[uintptr]int16
+		v173v1 = v
+		bs173, _ := testMarshalErr(v173v1, h, t, "enc-map-v173")
+		if v != nil {
+			v173v2 = make(map[uintptr]int16, len(v))
+		}
+		testUnmarshalErr(v173v2, bs173, h, t, "dec-map-v173")
+		testDeepEqualErr(v173v1, v173v2, t, "equal-map-v173")
+		bs173, _ = testMarshalErr(&v173v1, h, t, "enc-map-v173-p")
+		v173v2 = nil
+		testUnmarshalErr(&v173v2, bs173, h, t, "dec-map-v173-p")
+		testDeepEqualErr(v173v1, v173v2, t, "equal-map-v173-p")
+	}
+
+	for _, v := range []map[uintptr]int32{nil, map[uintptr]int32{}, map[uintptr]int32{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v174: %v\n", v)
+		var v174v1, v174v2 map[uintptr]int32
+		v174v1 = v
+		bs174, _ := testMarshalErr(v174v1, h, t, "enc-map-v174")
+		if v != nil {
+			v174v2 = make(map[uintptr]int32, len(v))
+		}
+		testUnmarshalErr(v174v2, bs174, h, t, "dec-map-v174")
+		testDeepEqualErr(v174v1, v174v2, t, "equal-map-v174")
+		bs174, _ = testMarshalErr(&v174v1, h, t, "enc-map-v174-p")
+		v174v2 = nil
+		testUnmarshalErr(&v174v2, bs174, h, t, "dec-map-v174-p")
+		testDeepEqualErr(v174v1, v174v2, t, "equal-map-v174-p")
+	}
+
+	for _, v := range []map[uintptr]int64{nil, map[uintptr]int64{}, map[uintptr]int64{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v175: %v\n", v)
+		var v175v1, v175v2 map[uintptr]int64
+		v175v1 = v
+		bs175, _ := testMarshalErr(v175v1, h, t, "enc-map-v175")
+		if v != nil {
+			v175v2 = make(map[uintptr]int64, len(v))
+		}
+		testUnmarshalErr(v175v2, bs175, h, t, "dec-map-v175")
+		testDeepEqualErr(v175v1, v175v2, t, "equal-map-v175")
+		bs175, _ = testMarshalErr(&v175v1, h, t, "enc-map-v175-p")
+		v175v2 = nil
+		testUnmarshalErr(&v175v2, bs175, h, t, "dec-map-v175-p")
+		testDeepEqualErr(v175v1, v175v2, t, "equal-map-v175-p")
+	}
+
+	for _, v := range []map[uintptr]float32{nil, map[uintptr]float32{}, map[uintptr]float32{10: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v176: %v\n", v)
+		var v176v1, v176v2 map[uintptr]float32
+		v176v1 = v
+		bs176, _ := testMarshalErr(v176v1, h, t, "enc-map-v176")
+		if v != nil {
+			v176v2 = make(map[uintptr]float32, len(v))
+		}
+		testUnmarshalErr(v176v2, bs176, h, t, "dec-map-v176")
+		testDeepEqualErr(v176v1, v176v2, t, "equal-map-v176")
+		bs176, _ = testMarshalErr(&v176v1, h, t, "enc-map-v176-p")
+		v176v2 = nil
+		testUnmarshalErr(&v176v2, bs176, h, t, "dec-map-v176-p")
+		testDeepEqualErr(v176v1, v176v2, t, "equal-map-v176-p")
+	}
+
+	for _, v := range []map[uintptr]float64{nil, map[uintptr]float64{}, map[uintptr]float64{10: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v177: %v\n", v)
+		var v177v1, v177v2 map[uintptr]float64
+		v177v1 = v
+		bs177, _ := testMarshalErr(v177v1, h, t, "enc-map-v177")
+		if v != nil {
+			v177v2 = make(map[uintptr]float64, len(v))
+		}
+		testUnmarshalErr(v177v2, bs177, h, t, "dec-map-v177")
+		testDeepEqualErr(v177v1, v177v2, t, "equal-map-v177")
+		bs177, _ = testMarshalErr(&v177v1, h, t, "enc-map-v177-p")
+		v177v2 = nil
+		testUnmarshalErr(&v177v2, bs177, h, t, "dec-map-v177-p")
+		testDeepEqualErr(v177v1, v177v2, t, "equal-map-v177-p")
+	}
+
+	for _, v := range []map[uintptr]bool{nil, map[uintptr]bool{}, map[uintptr]bool{10: true}} {
+		// fmt.Printf(">>>> running mammoth map v178: %v\n", v)
+		var v178v1, v178v2 map[uintptr]bool
+		v178v1 = v
+		bs178, _ := testMarshalErr(v178v1, h, t, "enc-map-v178")
+		if v != nil {
+			v178v2 = make(map[uintptr]bool, len(v))
+		}
+		testUnmarshalErr(v178v2, bs178, h, t, "dec-map-v178")
+		testDeepEqualErr(v178v1, v178v2, t, "equal-map-v178")
+		bs178, _ = testMarshalErr(&v178v1, h, t, "enc-map-v178-p")
+		v178v2 = nil
+		testUnmarshalErr(&v178v2, bs178, h, t, "dec-map-v178-p")
+		testDeepEqualErr(v178v1, v178v2, t, "equal-map-v178-p")
+	}
+
+	for _, v := range []map[int]interface{}{nil, map[int]interface{}{}, map[int]interface{}{10: "string-is-an-interface"}} {
+		// fmt.Printf(">>>> running mammoth map v181: %v\n", v)
+		var v181v1, v181v2 map[int]interface{}
+		v181v1 = v
+		bs181, _ := testMarshalErr(v181v1, h, t, "enc-map-v181")
+		if v != nil {
+			v181v2 = make(map[int]interface{}, len(v))
+		}
+		testUnmarshalErr(v181v2, bs181, h, t, "dec-map-v181")
+		testDeepEqualErr(v181v1, v181v2, t, "equal-map-v181")
+		bs181, _ = testMarshalErr(&v181v1, h, t, "enc-map-v181-p")
+		v181v2 = nil
+		testUnmarshalErr(&v181v2, bs181, h, t, "dec-map-v181-p")
+		testDeepEqualErr(v181v1, v181v2, t, "equal-map-v181-p")
+	}
+
+	for _, v := range []map[int]string{nil, map[int]string{}, map[int]string{10: "some-string"}} {
+		// fmt.Printf(">>>> running mammoth map v182: %v\n", v)
+		var v182v1, v182v2 map[int]string
+		v182v1 = v
+		bs182, _ := testMarshalErr(v182v1, h, t, "enc-map-v182")
+		if v != nil {
+			v182v2 = make(map[int]string, len(v))
+		}
+		testUnmarshalErr(v182v2, bs182, h, t, "dec-map-v182")
+		testDeepEqualErr(v182v1, v182v2, t, "equal-map-v182")
+		bs182, _ = testMarshalErr(&v182v1, h, t, "enc-map-v182-p")
+		v182v2 = nil
+		testUnmarshalErr(&v182v2, bs182, h, t, "dec-map-v182-p")
+		testDeepEqualErr(v182v1, v182v2, t, "equal-map-v182-p")
+	}
+
+	for _, v := range []map[int]uint{nil, map[int]uint{}, map[int]uint{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v183: %v\n", v)
+		var v183v1, v183v2 map[int]uint
+		v183v1 = v
+		bs183, _ := testMarshalErr(v183v1, h, t, "enc-map-v183")
+		if v != nil {
+			v183v2 = make(map[int]uint, len(v))
+		}
+		testUnmarshalErr(v183v2, bs183, h, t, "dec-map-v183")
+		testDeepEqualErr(v183v1, v183v2, t, "equal-map-v183")
+		bs183, _ = testMarshalErr(&v183v1, h, t, "enc-map-v183-p")
+		v183v2 = nil
+		testUnmarshalErr(&v183v2, bs183, h, t, "dec-map-v183-p")
+		testDeepEqualErr(v183v1, v183v2, t, "equal-map-v183-p")
+	}
+
+	for _, v := range []map[int]uint8{nil, map[int]uint8{}, map[int]uint8{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v184: %v\n", v)
+		var v184v1, v184v2 map[int]uint8
+		v184v1 = v
+		bs184, _ := testMarshalErr(v184v1, h, t, "enc-map-v184")
+		if v != nil {
+			v184v2 = make(map[int]uint8, len(v))
+		}
+		testUnmarshalErr(v184v2, bs184, h, t, "dec-map-v184")
+		testDeepEqualErr(v184v1, v184v2, t, "equal-map-v184")
+		bs184, _ = testMarshalErr(&v184v1, h, t, "enc-map-v184-p")
+		v184v2 = nil
+		testUnmarshalErr(&v184v2, bs184, h, t, "dec-map-v184-p")
+		testDeepEqualErr(v184v1, v184v2, t, "equal-map-v184-p")
+	}
+
+	for _, v := range []map[int]uint16{nil, map[int]uint16{}, map[int]uint16{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v185: %v\n", v)
+		var v185v1, v185v2 map[int]uint16
+		v185v1 = v
+		bs185, _ := testMarshalErr(v185v1, h, t, "enc-map-v185")
+		if v != nil {
+			v185v2 = make(map[int]uint16, len(v))
+		}
+		testUnmarshalErr(v185v2, bs185, h, t, "dec-map-v185")
+		testDeepEqualErr(v185v1, v185v2, t, "equal-map-v185")
+		bs185, _ = testMarshalErr(&v185v1, h, t, "enc-map-v185-p")
+		v185v2 = nil
+		testUnmarshalErr(&v185v2, bs185, h, t, "dec-map-v185-p")
+		testDeepEqualErr(v185v1, v185v2, t, "equal-map-v185-p")
+	}
+
+	for _, v := range []map[int]uint32{nil, map[int]uint32{}, map[int]uint32{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v186: %v\n", v)
+		var v186v1, v186v2 map[int]uint32
+		v186v1 = v
+		bs186, _ := testMarshalErr(v186v1, h, t, "enc-map-v186")
+		if v != nil {
+			v186v2 = make(map[int]uint32, len(v))
+		}
+		testUnmarshalErr(v186v2, bs186, h, t, "dec-map-v186")
+		testDeepEqualErr(v186v1, v186v2, t, "equal-map-v186")
+		bs186, _ = testMarshalErr(&v186v1, h, t, "enc-map-v186-p")
+		v186v2 = nil
+		testUnmarshalErr(&v186v2, bs186, h, t, "dec-map-v186-p")
+		testDeepEqualErr(v186v1, v186v2, t, "equal-map-v186-p")
+	}
+
+	for _, v := range []map[int]uint64{nil, map[int]uint64{}, map[int]uint64{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v187: %v\n", v)
+		var v187v1, v187v2 map[int]uint64
+		v187v1 = v
+		bs187, _ := testMarshalErr(v187v1, h, t, "enc-map-v187")
+		if v != nil {
+			v187v2 = make(map[int]uint64, len(v))
+		}
+		testUnmarshalErr(v187v2, bs187, h, t, "dec-map-v187")
+		testDeepEqualErr(v187v1, v187v2, t, "equal-map-v187")
+		bs187, _ = testMarshalErr(&v187v1, h, t, "enc-map-v187-p")
+		v187v2 = nil
+		testUnmarshalErr(&v187v2, bs187, h, t, "dec-map-v187-p")
+		testDeepEqualErr(v187v1, v187v2, t, "equal-map-v187-p")
+	}
+
+	for _, v := range []map[int]uintptr{nil, map[int]uintptr{}, map[int]uintptr{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v188: %v\n", v)
+		var v188v1, v188v2 map[int]uintptr
+		v188v1 = v
+		bs188, _ := testMarshalErr(v188v1, h, t, "enc-map-v188")
+		if v != nil {
+			v188v2 = make(map[int]uintptr, len(v))
+		}
+		testUnmarshalErr(v188v2, bs188, h, t, "dec-map-v188")
+		testDeepEqualErr(v188v1, v188v2, t, "equal-map-v188")
+		bs188, _ = testMarshalErr(&v188v1, h, t, "enc-map-v188-p")
+		v188v2 = nil
+		testUnmarshalErr(&v188v2, bs188, h, t, "dec-map-v188-p")
+		testDeepEqualErr(v188v1, v188v2, t, "equal-map-v188-p")
+	}
+
+	for _, v := range []map[int]int{nil, map[int]int{}, map[int]int{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v189: %v\n", v)
+		var v189v1, v189v2 map[int]int
+		v189v1 = v
+		bs189, _ := testMarshalErr(v189v1, h, t, "enc-map-v189")
+		if v != nil {
+			v189v2 = make(map[int]int, len(v))
+		}
+		testUnmarshalErr(v189v2, bs189, h, t, "dec-map-v189")
+		testDeepEqualErr(v189v1, v189v2, t, "equal-map-v189")
+		bs189, _ = testMarshalErr(&v189v1, h, t, "enc-map-v189-p")
+		v189v2 = nil
+		testUnmarshalErr(&v189v2, bs189, h, t, "dec-map-v189-p")
+		testDeepEqualErr(v189v1, v189v2, t, "equal-map-v189-p")
+	}
+
+	for _, v := range []map[int]int8{nil, map[int]int8{}, map[int]int8{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v190: %v\n", v)
+		var v190v1, v190v2 map[int]int8
+		v190v1 = v
+		bs190, _ := testMarshalErr(v190v1, h, t, "enc-map-v190")
+		if v != nil {
+			v190v2 = make(map[int]int8, len(v))
+		}
+		testUnmarshalErr(v190v2, bs190, h, t, "dec-map-v190")
+		testDeepEqualErr(v190v1, v190v2, t, "equal-map-v190")
+		bs190, _ = testMarshalErr(&v190v1, h, t, "enc-map-v190-p")
+		v190v2 = nil
+		testUnmarshalErr(&v190v2, bs190, h, t, "dec-map-v190-p")
+		testDeepEqualErr(v190v1, v190v2, t, "equal-map-v190-p")
+	}
+
+	for _, v := range []map[int]int16{nil, map[int]int16{}, map[int]int16{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v191: %v\n", v)
+		var v191v1, v191v2 map[int]int16
+		v191v1 = v
+		bs191, _ := testMarshalErr(v191v1, h, t, "enc-map-v191")
+		if v != nil {
+			v191v2 = make(map[int]int16, len(v))
+		}
+		testUnmarshalErr(v191v2, bs191, h, t, "dec-map-v191")
+		testDeepEqualErr(v191v1, v191v2, t, "equal-map-v191")
+		bs191, _ = testMarshalErr(&v191v1, h, t, "enc-map-v191-p")
+		v191v2 = nil
+		testUnmarshalErr(&v191v2, bs191, h, t, "dec-map-v191-p")
+		testDeepEqualErr(v191v1, v191v2, t, "equal-map-v191-p")
+	}
+
+	for _, v := range []map[int]int32{nil, map[int]int32{}, map[int]int32{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v192: %v\n", v)
+		var v192v1, v192v2 map[int]int32
+		v192v1 = v
+		bs192, _ := testMarshalErr(v192v1, h, t, "enc-map-v192")
+		if v != nil {
+			v192v2 = make(map[int]int32, len(v))
+		}
+		testUnmarshalErr(v192v2, bs192, h, t, "dec-map-v192")
+		testDeepEqualErr(v192v1, v192v2, t, "equal-map-v192")
+		bs192, _ = testMarshalErr(&v192v1, h, t, "enc-map-v192-p")
+		v192v2 = nil
+		testUnmarshalErr(&v192v2, bs192, h, t, "dec-map-v192-p")
+		testDeepEqualErr(v192v1, v192v2, t, "equal-map-v192-p")
+	}
+
+	for _, v := range []map[int]int64{nil, map[int]int64{}, map[int]int64{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v193: %v\n", v)
+		var v193v1, v193v2 map[int]int64
+		v193v1 = v
+		bs193, _ := testMarshalErr(v193v1, h, t, "enc-map-v193")
+		if v != nil {
+			v193v2 = make(map[int]int64, len(v))
+		}
+		testUnmarshalErr(v193v2, bs193, h, t, "dec-map-v193")
+		testDeepEqualErr(v193v1, v193v2, t, "equal-map-v193")
+		bs193, _ = testMarshalErr(&v193v1, h, t, "enc-map-v193-p")
+		v193v2 = nil
+		testUnmarshalErr(&v193v2, bs193, h, t, "dec-map-v193-p")
+		testDeepEqualErr(v193v1, v193v2, t, "equal-map-v193-p")
+	}
+
+	for _, v := range []map[int]float32{nil, map[int]float32{}, map[int]float32{10: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v194: %v\n", v)
+		var v194v1, v194v2 map[int]float32
+		v194v1 = v
+		bs194, _ := testMarshalErr(v194v1, h, t, "enc-map-v194")
+		if v != nil {
+			v194v2 = make(map[int]float32, len(v))
+		}
+		testUnmarshalErr(v194v2, bs194, h, t, "dec-map-v194")
+		testDeepEqualErr(v194v1, v194v2, t, "equal-map-v194")
+		bs194, _ = testMarshalErr(&v194v1, h, t, "enc-map-v194-p")
+		v194v2 = nil
+		testUnmarshalErr(&v194v2, bs194, h, t, "dec-map-v194-p")
+		testDeepEqualErr(v194v1, v194v2, t, "equal-map-v194-p")
+	}
+
+	for _, v := range []map[int]float64{nil, map[int]float64{}, map[int]float64{10: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v195: %v\n", v)
+		var v195v1, v195v2 map[int]float64
+		v195v1 = v
+		bs195, _ := testMarshalErr(v195v1, h, t, "enc-map-v195")
+		if v != nil {
+			v195v2 = make(map[int]float64, len(v))
+		}
+		testUnmarshalErr(v195v2, bs195, h, t, "dec-map-v195")
+		testDeepEqualErr(v195v1, v195v2, t, "equal-map-v195")
+		bs195, _ = testMarshalErr(&v195v1, h, t, "enc-map-v195-p")
+		v195v2 = nil
+		testUnmarshalErr(&v195v2, bs195, h, t, "dec-map-v195-p")
+		testDeepEqualErr(v195v1, v195v2, t, "equal-map-v195-p")
+	}
+
+	for _, v := range []map[int]bool{nil, map[int]bool{}, map[int]bool{10: true}} {
+		// fmt.Printf(">>>> running mammoth map v196: %v\n", v)
+		var v196v1, v196v2 map[int]bool
+		v196v1 = v
+		bs196, _ := testMarshalErr(v196v1, h, t, "enc-map-v196")
+		if v != nil {
+			v196v2 = make(map[int]bool, len(v))
+		}
+		testUnmarshalErr(v196v2, bs196, h, t, "dec-map-v196")
+		testDeepEqualErr(v196v1, v196v2, t, "equal-map-v196")
+		bs196, _ = testMarshalErr(&v196v1, h, t, "enc-map-v196-p")
+		v196v2 = nil
+		testUnmarshalErr(&v196v2, bs196, h, t, "dec-map-v196-p")
+		testDeepEqualErr(v196v1, v196v2, t, "equal-map-v196-p")
+	}
+
+	for _, v := range []map[int8]interface{}{nil, map[int8]interface{}{}, map[int8]interface{}{10: "string-is-an-interface"}} {
+		// fmt.Printf(">>>> running mammoth map v199: %v\n", v)
+		var v199v1, v199v2 map[int8]interface{}
+		v199v1 = v
+		bs199, _ := testMarshalErr(v199v1, h, t, "enc-map-v199")
+		if v != nil {
+			v199v2 = make(map[int8]interface{}, len(v))
+		}
+		testUnmarshalErr(v199v2, bs199, h, t, "dec-map-v199")
+		testDeepEqualErr(v199v1, v199v2, t, "equal-map-v199")
+		bs199, _ = testMarshalErr(&v199v1, h, t, "enc-map-v199-p")
+		v199v2 = nil
+		testUnmarshalErr(&v199v2, bs199, h, t, "dec-map-v199-p")
+		testDeepEqualErr(v199v1, v199v2, t, "equal-map-v199-p")
+	}
+
+	for _, v := range []map[int8]string{nil, map[int8]string{}, map[int8]string{10: "some-string"}} {
+		// fmt.Printf(">>>> running mammoth map v200: %v\n", v)
+		var v200v1, v200v2 map[int8]string
+		v200v1 = v
+		bs200, _ := testMarshalErr(v200v1, h, t, "enc-map-v200")
+		if v != nil {
+			v200v2 = make(map[int8]string, len(v))
+		}
+		testUnmarshalErr(v200v2, bs200, h, t, "dec-map-v200")
+		testDeepEqualErr(v200v1, v200v2, t, "equal-map-v200")
+		bs200, _ = testMarshalErr(&v200v1, h, t, "enc-map-v200-p")
+		v200v2 = nil
+		testUnmarshalErr(&v200v2, bs200, h, t, "dec-map-v200-p")
+		testDeepEqualErr(v200v1, v200v2, t, "equal-map-v200-p")
+	}
+
+	for _, v := range []map[int8]uint{nil, map[int8]uint{}, map[int8]uint{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v201: %v\n", v)
+		var v201v1, v201v2 map[int8]uint
+		v201v1 = v
+		bs201, _ := testMarshalErr(v201v1, h, t, "enc-map-v201")
+		if v != nil {
+			v201v2 = make(map[int8]uint, len(v))
+		}
+		testUnmarshalErr(v201v2, bs201, h, t, "dec-map-v201")
+		testDeepEqualErr(v201v1, v201v2, t, "equal-map-v201")
+		bs201, _ = testMarshalErr(&v201v1, h, t, "enc-map-v201-p")
+		v201v2 = nil
+		testUnmarshalErr(&v201v2, bs201, h, t, "dec-map-v201-p")
+		testDeepEqualErr(v201v1, v201v2, t, "equal-map-v201-p")
+	}
+
+	for _, v := range []map[int8]uint8{nil, map[int8]uint8{}, map[int8]uint8{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v202: %v\n", v)
+		var v202v1, v202v2 map[int8]uint8
+		v202v1 = v
+		bs202, _ := testMarshalErr(v202v1, h, t, "enc-map-v202")
+		if v != nil {
+			v202v2 = make(map[int8]uint8, len(v))
+		}
+		testUnmarshalErr(v202v2, bs202, h, t, "dec-map-v202")
+		testDeepEqualErr(v202v1, v202v2, t, "equal-map-v202")
+		bs202, _ = testMarshalErr(&v202v1, h, t, "enc-map-v202-p")
+		v202v2 = nil
+		testUnmarshalErr(&v202v2, bs202, h, t, "dec-map-v202-p")
+		testDeepEqualErr(v202v1, v202v2, t, "equal-map-v202-p")
+	}
+
+	for _, v := range []map[int8]uint16{nil, map[int8]uint16{}, map[int8]uint16{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v203: %v\n", v)
+		var v203v1, v203v2 map[int8]uint16
+		v203v1 = v
+		bs203, _ := testMarshalErr(v203v1, h, t, "enc-map-v203")
+		if v != nil {
+			v203v2 = make(map[int8]uint16, len(v))
+		}
+		testUnmarshalErr(v203v2, bs203, h, t, "dec-map-v203")
+		testDeepEqualErr(v203v1, v203v2, t, "equal-map-v203")
+		bs203, _ = testMarshalErr(&v203v1, h, t, "enc-map-v203-p")
+		v203v2 = nil
+		testUnmarshalErr(&v203v2, bs203, h, t, "dec-map-v203-p")
+		testDeepEqualErr(v203v1, v203v2, t, "equal-map-v203-p")
+	}
+
+	for _, v := range []map[int8]uint32{nil, map[int8]uint32{}, map[int8]uint32{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v204: %v\n", v)
+		var v204v1, v204v2 map[int8]uint32
+		v204v1 = v
+		bs204, _ := testMarshalErr(v204v1, h, t, "enc-map-v204")
+		if v != nil {
+			v204v2 = make(map[int8]uint32, len(v))
+		}
+		testUnmarshalErr(v204v2, bs204, h, t, "dec-map-v204")
+		testDeepEqualErr(v204v1, v204v2, t, "equal-map-v204")
+		bs204, _ = testMarshalErr(&v204v1, h, t, "enc-map-v204-p")
+		v204v2 = nil
+		testUnmarshalErr(&v204v2, bs204, h, t, "dec-map-v204-p")
+		testDeepEqualErr(v204v1, v204v2, t, "equal-map-v204-p")
+	}
+
+	for _, v := range []map[int8]uint64{nil, map[int8]uint64{}, map[int8]uint64{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v205: %v\n", v)
+		var v205v1, v205v2 map[int8]uint64
+		v205v1 = v
+		bs205, _ := testMarshalErr(v205v1, h, t, "enc-map-v205")
+		if v != nil {
+			v205v2 = make(map[int8]uint64, len(v))
+		}
+		testUnmarshalErr(v205v2, bs205, h, t, "dec-map-v205")
+		testDeepEqualErr(v205v1, v205v2, t, "equal-map-v205")
+		bs205, _ = testMarshalErr(&v205v1, h, t, "enc-map-v205-p")
+		v205v2 = nil
+		testUnmarshalErr(&v205v2, bs205, h, t, "dec-map-v205-p")
+		testDeepEqualErr(v205v1, v205v2, t, "equal-map-v205-p")
+	}
+
+	for _, v := range []map[int8]uintptr{nil, map[int8]uintptr{}, map[int8]uintptr{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v206: %v\n", v)
+		var v206v1, v206v2 map[int8]uintptr
+		v206v1 = v
+		bs206, _ := testMarshalErr(v206v1, h, t, "enc-map-v206")
+		if v != nil {
+			v206v2 = make(map[int8]uintptr, len(v))
+		}
+		testUnmarshalErr(v206v2, bs206, h, t, "dec-map-v206")
+		testDeepEqualErr(v206v1, v206v2, t, "equal-map-v206")
+		bs206, _ = testMarshalErr(&v206v1, h, t, "enc-map-v206-p")
+		v206v2 = nil
+		testUnmarshalErr(&v206v2, bs206, h, t, "dec-map-v206-p")
+		testDeepEqualErr(v206v1, v206v2, t, "equal-map-v206-p")
+	}
+
+	for _, v := range []map[int8]int{nil, map[int8]int{}, map[int8]int{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v207: %v\n", v)
+		var v207v1, v207v2 map[int8]int
+		v207v1 = v
+		bs207, _ := testMarshalErr(v207v1, h, t, "enc-map-v207")
+		if v != nil {
+			v207v2 = make(map[int8]int, len(v))
+		}
+		testUnmarshalErr(v207v2, bs207, h, t, "dec-map-v207")
+		testDeepEqualErr(v207v1, v207v2, t, "equal-map-v207")
+		bs207, _ = testMarshalErr(&v207v1, h, t, "enc-map-v207-p")
+		v207v2 = nil
+		testUnmarshalErr(&v207v2, bs207, h, t, "dec-map-v207-p")
+		testDeepEqualErr(v207v1, v207v2, t, "equal-map-v207-p")
+	}
+
+	for _, v := range []map[int8]int8{nil, map[int8]int8{}, map[int8]int8{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v208: %v\n", v)
+		var v208v1, v208v2 map[int8]int8
+		v208v1 = v
+		bs208, _ := testMarshalErr(v208v1, h, t, "enc-map-v208")
+		if v != nil {
+			v208v2 = make(map[int8]int8, len(v))
+		}
+		testUnmarshalErr(v208v2, bs208, h, t, "dec-map-v208")
+		testDeepEqualErr(v208v1, v208v2, t, "equal-map-v208")
+		bs208, _ = testMarshalErr(&v208v1, h, t, "enc-map-v208-p")
+		v208v2 = nil
+		testUnmarshalErr(&v208v2, bs208, h, t, "dec-map-v208-p")
+		testDeepEqualErr(v208v1, v208v2, t, "equal-map-v208-p")
+	}
+
+	for _, v := range []map[int8]int16{nil, map[int8]int16{}, map[int8]int16{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v209: %v\n", v)
+		var v209v1, v209v2 map[int8]int16
+		v209v1 = v
+		bs209, _ := testMarshalErr(v209v1, h, t, "enc-map-v209")
+		if v != nil {
+			v209v2 = make(map[int8]int16, len(v))
+		}
+		testUnmarshalErr(v209v2, bs209, h, t, "dec-map-v209")
+		testDeepEqualErr(v209v1, v209v2, t, "equal-map-v209")
+		bs209, _ = testMarshalErr(&v209v1, h, t, "enc-map-v209-p")
+		v209v2 = nil
+		testUnmarshalErr(&v209v2, bs209, h, t, "dec-map-v209-p")
+		testDeepEqualErr(v209v1, v209v2, t, "equal-map-v209-p")
+	}
+
+	for _, v := range []map[int8]int32{nil, map[int8]int32{}, map[int8]int32{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v210: %v\n", v)
+		var v210v1, v210v2 map[int8]int32
+		v210v1 = v
+		bs210, _ := testMarshalErr(v210v1, h, t, "enc-map-v210")
+		if v != nil {
+			v210v2 = make(map[int8]int32, len(v))
+		}
+		testUnmarshalErr(v210v2, bs210, h, t, "dec-map-v210")
+		testDeepEqualErr(v210v1, v210v2, t, "equal-map-v210")
+		bs210, _ = testMarshalErr(&v210v1, h, t, "enc-map-v210-p")
+		v210v2 = nil
+		testUnmarshalErr(&v210v2, bs210, h, t, "dec-map-v210-p")
+		testDeepEqualErr(v210v1, v210v2, t, "equal-map-v210-p")
+	}
+
+	for _, v := range []map[int8]int64{nil, map[int8]int64{}, map[int8]int64{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v211: %v\n", v)
+		var v211v1, v211v2 map[int8]int64
+		v211v1 = v
+		bs211, _ := testMarshalErr(v211v1, h, t, "enc-map-v211")
+		if v != nil {
+			v211v2 = make(map[int8]int64, len(v))
+		}
+		testUnmarshalErr(v211v2, bs211, h, t, "dec-map-v211")
+		testDeepEqualErr(v211v1, v211v2, t, "equal-map-v211")
+		bs211, _ = testMarshalErr(&v211v1, h, t, "enc-map-v211-p")
+		v211v2 = nil
+		testUnmarshalErr(&v211v2, bs211, h, t, "dec-map-v211-p")
+		testDeepEqualErr(v211v1, v211v2, t, "equal-map-v211-p")
+	}
+
+	for _, v := range []map[int8]float32{nil, map[int8]float32{}, map[int8]float32{10: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v212: %v\n", v)
+		var v212v1, v212v2 map[int8]float32
+		v212v1 = v
+		bs212, _ := testMarshalErr(v212v1, h, t, "enc-map-v212")
+		if v != nil {
+			v212v2 = make(map[int8]float32, len(v))
+		}
+		testUnmarshalErr(v212v2, bs212, h, t, "dec-map-v212")
+		testDeepEqualErr(v212v1, v212v2, t, "equal-map-v212")
+		bs212, _ = testMarshalErr(&v212v1, h, t, "enc-map-v212-p")
+		v212v2 = nil
+		testUnmarshalErr(&v212v2, bs212, h, t, "dec-map-v212-p")
+		testDeepEqualErr(v212v1, v212v2, t, "equal-map-v212-p")
+	}
+
+	for _, v := range []map[int8]float64{nil, map[int8]float64{}, map[int8]float64{10: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v213: %v\n", v)
+		var v213v1, v213v2 map[int8]float64
+		v213v1 = v
+		bs213, _ := testMarshalErr(v213v1, h, t, "enc-map-v213")
+		if v != nil {
+			v213v2 = make(map[int8]float64, len(v))
+		}
+		testUnmarshalErr(v213v2, bs213, h, t, "dec-map-v213")
+		testDeepEqualErr(v213v1, v213v2, t, "equal-map-v213")
+		bs213, _ = testMarshalErr(&v213v1, h, t, "enc-map-v213-p")
+		v213v2 = nil
+		testUnmarshalErr(&v213v2, bs213, h, t, "dec-map-v213-p")
+		testDeepEqualErr(v213v1, v213v2, t, "equal-map-v213-p")
+	}
+
+	for _, v := range []map[int8]bool{nil, map[int8]bool{}, map[int8]bool{10: true}} {
+		// fmt.Printf(">>>> running mammoth map v214: %v\n", v)
+		var v214v1, v214v2 map[int8]bool
+		v214v1 = v
+		bs214, _ := testMarshalErr(v214v1, h, t, "enc-map-v214")
+		if v != nil {
+			v214v2 = make(map[int8]bool, len(v))
+		}
+		testUnmarshalErr(v214v2, bs214, h, t, "dec-map-v214")
+		testDeepEqualErr(v214v1, v214v2, t, "equal-map-v214")
+		bs214, _ = testMarshalErr(&v214v1, h, t, "enc-map-v214-p")
+		v214v2 = nil
+		testUnmarshalErr(&v214v2, bs214, h, t, "dec-map-v214-p")
+		testDeepEqualErr(v214v1, v214v2, t, "equal-map-v214-p")
+	}
+
+	for _, v := range []map[int16]interface{}{nil, map[int16]interface{}{}, map[int16]interface{}{10: "string-is-an-interface"}} {
+		// fmt.Printf(">>>> running mammoth map v217: %v\n", v)
+		var v217v1, v217v2 map[int16]interface{}
+		v217v1 = v
+		bs217, _ := testMarshalErr(v217v1, h, t, "enc-map-v217")
+		if v != nil {
+			v217v2 = make(map[int16]interface{}, len(v))
+		}
+		testUnmarshalErr(v217v2, bs217, h, t, "dec-map-v217")
+		testDeepEqualErr(v217v1, v217v2, t, "equal-map-v217")
+		bs217, _ = testMarshalErr(&v217v1, h, t, "enc-map-v217-p")
+		v217v2 = nil
+		testUnmarshalErr(&v217v2, bs217, h, t, "dec-map-v217-p")
+		testDeepEqualErr(v217v1, v217v2, t, "equal-map-v217-p")
+	}
+
+	for _, v := range []map[int16]string{nil, map[int16]string{}, map[int16]string{10: "some-string"}} {
+		// fmt.Printf(">>>> running mammoth map v218: %v\n", v)
+		var v218v1, v218v2 map[int16]string
+		v218v1 = v
+		bs218, _ := testMarshalErr(v218v1, h, t, "enc-map-v218")
+		if v != nil {
+			v218v2 = make(map[int16]string, len(v))
+		}
+		testUnmarshalErr(v218v2, bs218, h, t, "dec-map-v218")
+		testDeepEqualErr(v218v1, v218v2, t, "equal-map-v218")
+		bs218, _ = testMarshalErr(&v218v1, h, t, "enc-map-v218-p")
+		v218v2 = nil
+		testUnmarshalErr(&v218v2, bs218, h, t, "dec-map-v218-p")
+		testDeepEqualErr(v218v1, v218v2, t, "equal-map-v218-p")
+	}
+
+	for _, v := range []map[int16]uint{nil, map[int16]uint{}, map[int16]uint{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v219: %v\n", v)
+		var v219v1, v219v2 map[int16]uint
+		v219v1 = v
+		bs219, _ := testMarshalErr(v219v1, h, t, "enc-map-v219")
+		if v != nil {
+			v219v2 = make(map[int16]uint, len(v))
+		}
+		testUnmarshalErr(v219v2, bs219, h, t, "dec-map-v219")
+		testDeepEqualErr(v219v1, v219v2, t, "equal-map-v219")
+		bs219, _ = testMarshalErr(&v219v1, h, t, "enc-map-v219-p")
+		v219v2 = nil
+		testUnmarshalErr(&v219v2, bs219, h, t, "dec-map-v219-p")
+		testDeepEqualErr(v219v1, v219v2, t, "equal-map-v219-p")
+	}
+
+	for _, v := range []map[int16]uint8{nil, map[int16]uint8{}, map[int16]uint8{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v220: %v\n", v)
+		var v220v1, v220v2 map[int16]uint8
+		v220v1 = v
+		bs220, _ := testMarshalErr(v220v1, h, t, "enc-map-v220")
+		if v != nil {
+			v220v2 = make(map[int16]uint8, len(v))
+		}
+		testUnmarshalErr(v220v2, bs220, h, t, "dec-map-v220")
+		testDeepEqualErr(v220v1, v220v2, t, "equal-map-v220")
+		bs220, _ = testMarshalErr(&v220v1, h, t, "enc-map-v220-p")
+		v220v2 = nil
+		testUnmarshalErr(&v220v2, bs220, h, t, "dec-map-v220-p")
+		testDeepEqualErr(v220v1, v220v2, t, "equal-map-v220-p")
+	}
+
+	for _, v := range []map[int16]uint16{nil, map[int16]uint16{}, map[int16]uint16{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v221: %v\n", v)
+		var v221v1, v221v2 map[int16]uint16
+		v221v1 = v
+		bs221, _ := testMarshalErr(v221v1, h, t, "enc-map-v221")
+		if v != nil {
+			v221v2 = make(map[int16]uint16, len(v))
+		}
+		testUnmarshalErr(v221v2, bs221, h, t, "dec-map-v221")
+		testDeepEqualErr(v221v1, v221v2, t, "equal-map-v221")
+		bs221, _ = testMarshalErr(&v221v1, h, t, "enc-map-v221-p")
+		v221v2 = nil
+		testUnmarshalErr(&v221v2, bs221, h, t, "dec-map-v221-p")
+		testDeepEqualErr(v221v1, v221v2, t, "equal-map-v221-p")
+	}
+
+	for _, v := range []map[int16]uint32{nil, map[int16]uint32{}, map[int16]uint32{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v222: %v\n", v)
+		var v222v1, v222v2 map[int16]uint32
+		v222v1 = v
+		bs222, _ := testMarshalErr(v222v1, h, t, "enc-map-v222")
+		if v != nil {
+			v222v2 = make(map[int16]uint32, len(v))
+		}
+		testUnmarshalErr(v222v2, bs222, h, t, "dec-map-v222")
+		testDeepEqualErr(v222v1, v222v2, t, "equal-map-v222")
+		bs222, _ = testMarshalErr(&v222v1, h, t, "enc-map-v222-p")
+		v222v2 = nil
+		testUnmarshalErr(&v222v2, bs222, h, t, "dec-map-v222-p")
+		testDeepEqualErr(v222v1, v222v2, t, "equal-map-v222-p")
+	}
+
+	for _, v := range []map[int16]uint64{nil, map[int16]uint64{}, map[int16]uint64{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v223: %v\n", v)
+		var v223v1, v223v2 map[int16]uint64
+		v223v1 = v
+		bs223, _ := testMarshalErr(v223v1, h, t, "enc-map-v223")
+		if v != nil {
+			v223v2 = make(map[int16]uint64, len(v))
+		}
+		testUnmarshalErr(v223v2, bs223, h, t, "dec-map-v223")
+		testDeepEqualErr(v223v1, v223v2, t, "equal-map-v223")
+		bs223, _ = testMarshalErr(&v223v1, h, t, "enc-map-v223-p")
+		v223v2 = nil
+		testUnmarshalErr(&v223v2, bs223, h, t, "dec-map-v223-p")
+		testDeepEqualErr(v223v1, v223v2, t, "equal-map-v223-p")
+	}
+
+	for _, v := range []map[int16]uintptr{nil, map[int16]uintptr{}, map[int16]uintptr{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v224: %v\n", v)
+		var v224v1, v224v2 map[int16]uintptr
+		v224v1 = v
+		bs224, _ := testMarshalErr(v224v1, h, t, "enc-map-v224")
+		if v != nil {
+			v224v2 = make(map[int16]uintptr, len(v))
+		}
+		testUnmarshalErr(v224v2, bs224, h, t, "dec-map-v224")
+		testDeepEqualErr(v224v1, v224v2, t, "equal-map-v224")
+		bs224, _ = testMarshalErr(&v224v1, h, t, "enc-map-v224-p")
+		v224v2 = nil
+		testUnmarshalErr(&v224v2, bs224, h, t, "dec-map-v224-p")
+		testDeepEqualErr(v224v1, v224v2, t, "equal-map-v224-p")
+	}
+
+	for _, v := range []map[int16]int{nil, map[int16]int{}, map[int16]int{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v225: %v\n", v)
+		var v225v1, v225v2 map[int16]int
+		v225v1 = v
+		bs225, _ := testMarshalErr(v225v1, h, t, "enc-map-v225")
+		if v != nil {
+			v225v2 = make(map[int16]int, len(v))
+		}
+		testUnmarshalErr(v225v2, bs225, h, t, "dec-map-v225")
+		testDeepEqualErr(v225v1, v225v2, t, "equal-map-v225")
+		bs225, _ = testMarshalErr(&v225v1, h, t, "enc-map-v225-p")
+		v225v2 = nil
+		testUnmarshalErr(&v225v2, bs225, h, t, "dec-map-v225-p")
+		testDeepEqualErr(v225v1, v225v2, t, "equal-map-v225-p")
+	}
+
+	for _, v := range []map[int16]int8{nil, map[int16]int8{}, map[int16]int8{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v226: %v\n", v)
+		var v226v1, v226v2 map[int16]int8
+		v226v1 = v
+		bs226, _ := testMarshalErr(v226v1, h, t, "enc-map-v226")
+		if v != nil {
+			v226v2 = make(map[int16]int8, len(v))
+		}
+		testUnmarshalErr(v226v2, bs226, h, t, "dec-map-v226")
+		testDeepEqualErr(v226v1, v226v2, t, "equal-map-v226")
+		bs226, _ = testMarshalErr(&v226v1, h, t, "enc-map-v226-p")
+		v226v2 = nil
+		testUnmarshalErr(&v226v2, bs226, h, t, "dec-map-v226-p")
+		testDeepEqualErr(v226v1, v226v2, t, "equal-map-v226-p")
+	}
+
+	for _, v := range []map[int16]int16{nil, map[int16]int16{}, map[int16]int16{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v227: %v\n", v)
+		var v227v1, v227v2 map[int16]int16
+		v227v1 = v
+		bs227, _ := testMarshalErr(v227v1, h, t, "enc-map-v227")
+		if v != nil {
+			v227v2 = make(map[int16]int16, len(v))
+		}
+		testUnmarshalErr(v227v2, bs227, h, t, "dec-map-v227")
+		testDeepEqualErr(v227v1, v227v2, t, "equal-map-v227")
+		bs227, _ = testMarshalErr(&v227v1, h, t, "enc-map-v227-p")
+		v227v2 = nil
+		testUnmarshalErr(&v227v2, bs227, h, t, "dec-map-v227-p")
+		testDeepEqualErr(v227v1, v227v2, t, "equal-map-v227-p")
+	}
+
+	for _, v := range []map[int16]int32{nil, map[int16]int32{}, map[int16]int32{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v228: %v\n", v)
+		var v228v1, v228v2 map[int16]int32
+		v228v1 = v
+		bs228, _ := testMarshalErr(v228v1, h, t, "enc-map-v228")
+		if v != nil {
+			v228v2 = make(map[int16]int32, len(v))
+		}
+		testUnmarshalErr(v228v2, bs228, h, t, "dec-map-v228")
+		testDeepEqualErr(v228v1, v228v2, t, "equal-map-v228")
+		bs228, _ = testMarshalErr(&v228v1, h, t, "enc-map-v228-p")
+		v228v2 = nil
+		testUnmarshalErr(&v228v2, bs228, h, t, "dec-map-v228-p")
+		testDeepEqualErr(v228v1, v228v2, t, "equal-map-v228-p")
+	}
+
+	for _, v := range []map[int16]int64{nil, map[int16]int64{}, map[int16]int64{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v229: %v\n", v)
+		var v229v1, v229v2 map[int16]int64
+		v229v1 = v
+		bs229, _ := testMarshalErr(v229v1, h, t, "enc-map-v229")
+		if v != nil {
+			v229v2 = make(map[int16]int64, len(v))
+		}
+		testUnmarshalErr(v229v2, bs229, h, t, "dec-map-v229")
+		testDeepEqualErr(v229v1, v229v2, t, "equal-map-v229")
+		bs229, _ = testMarshalErr(&v229v1, h, t, "enc-map-v229-p")
+		v229v2 = nil
+		testUnmarshalErr(&v229v2, bs229, h, t, "dec-map-v229-p")
+		testDeepEqualErr(v229v1, v229v2, t, "equal-map-v229-p")
+	}
+
+	for _, v := range []map[int16]float32{nil, map[int16]float32{}, map[int16]float32{10: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v230: %v\n", v)
+		var v230v1, v230v2 map[int16]float32
+		v230v1 = v
+		bs230, _ := testMarshalErr(v230v1, h, t, "enc-map-v230")
+		if v != nil {
+			v230v2 = make(map[int16]float32, len(v))
+		}
+		testUnmarshalErr(v230v2, bs230, h, t, "dec-map-v230")
+		testDeepEqualErr(v230v1, v230v2, t, "equal-map-v230")
+		bs230, _ = testMarshalErr(&v230v1, h, t, "enc-map-v230-p")
+		v230v2 = nil
+		testUnmarshalErr(&v230v2, bs230, h, t, "dec-map-v230-p")
+		testDeepEqualErr(v230v1, v230v2, t, "equal-map-v230-p")
+	}
+
+	for _, v := range []map[int16]float64{nil, map[int16]float64{}, map[int16]float64{10: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v231: %v\n", v)
+		var v231v1, v231v2 map[int16]float64
+		v231v1 = v
+		bs231, _ := testMarshalErr(v231v1, h, t, "enc-map-v231")
+		if v != nil {
+			v231v2 = make(map[int16]float64, len(v))
+		}
+		testUnmarshalErr(v231v2, bs231, h, t, "dec-map-v231")
+		testDeepEqualErr(v231v1, v231v2, t, "equal-map-v231")
+		bs231, _ = testMarshalErr(&v231v1, h, t, "enc-map-v231-p")
+		v231v2 = nil
+		testUnmarshalErr(&v231v2, bs231, h, t, "dec-map-v231-p")
+		testDeepEqualErr(v231v1, v231v2, t, "equal-map-v231-p")
+	}
+
+	for _, v := range []map[int16]bool{nil, map[int16]bool{}, map[int16]bool{10: true}} {
+		// fmt.Printf(">>>> running mammoth map v232: %v\n", v)
+		var v232v1, v232v2 map[int16]bool
+		v232v1 = v
+		bs232, _ := testMarshalErr(v232v1, h, t, "enc-map-v232")
+		if v != nil {
+			v232v2 = make(map[int16]bool, len(v))
+		}
+		testUnmarshalErr(v232v2, bs232, h, t, "dec-map-v232")
+		testDeepEqualErr(v232v1, v232v2, t, "equal-map-v232")
+		bs232, _ = testMarshalErr(&v232v1, h, t, "enc-map-v232-p")
+		v232v2 = nil
+		testUnmarshalErr(&v232v2, bs232, h, t, "dec-map-v232-p")
+		testDeepEqualErr(v232v1, v232v2, t, "equal-map-v232-p")
+	}
+
+	for _, v := range []map[int32]interface{}{nil, map[int32]interface{}{}, map[int32]interface{}{10: "string-is-an-interface"}} {
+		// fmt.Printf(">>>> running mammoth map v235: %v\n", v)
+		var v235v1, v235v2 map[int32]interface{}
+		v235v1 = v
+		bs235, _ := testMarshalErr(v235v1, h, t, "enc-map-v235")
+		if v != nil {
+			v235v2 = make(map[int32]interface{}, len(v))
+		}
+		testUnmarshalErr(v235v2, bs235, h, t, "dec-map-v235")
+		testDeepEqualErr(v235v1, v235v2, t, "equal-map-v235")
+		bs235, _ = testMarshalErr(&v235v1, h, t, "enc-map-v235-p")
+		v235v2 = nil
+		testUnmarshalErr(&v235v2, bs235, h, t, "dec-map-v235-p")
+		testDeepEqualErr(v235v1, v235v2, t, "equal-map-v235-p")
+	}
+
+	for _, v := range []map[int32]string{nil, map[int32]string{}, map[int32]string{10: "some-string"}} {
+		// fmt.Printf(">>>> running mammoth map v236: %v\n", v)
+		var v236v1, v236v2 map[int32]string
+		v236v1 = v
+		bs236, _ := testMarshalErr(v236v1, h, t, "enc-map-v236")
+		if v != nil {
+			v236v2 = make(map[int32]string, len(v))
+		}
+		testUnmarshalErr(v236v2, bs236, h, t, "dec-map-v236")
+		testDeepEqualErr(v236v1, v236v2, t, "equal-map-v236")
+		bs236, _ = testMarshalErr(&v236v1, h, t, "enc-map-v236-p")
+		v236v2 = nil
+		testUnmarshalErr(&v236v2, bs236, h, t, "dec-map-v236-p")
+		testDeepEqualErr(v236v1, v236v2, t, "equal-map-v236-p")
+	}
+
+	for _, v := range []map[int32]uint{nil, map[int32]uint{}, map[int32]uint{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v237: %v\n", v)
+		var v237v1, v237v2 map[int32]uint
+		v237v1 = v
+		bs237, _ := testMarshalErr(v237v1, h, t, "enc-map-v237")
+		if v != nil {
+			v237v2 = make(map[int32]uint, len(v))
+		}
+		testUnmarshalErr(v237v2, bs237, h, t, "dec-map-v237")
+		testDeepEqualErr(v237v1, v237v2, t, "equal-map-v237")
+		bs237, _ = testMarshalErr(&v237v1, h, t, "enc-map-v237-p")
+		v237v2 = nil
+		testUnmarshalErr(&v237v2, bs237, h, t, "dec-map-v237-p")
+		testDeepEqualErr(v237v1, v237v2, t, "equal-map-v237-p")
+	}
+
+	for _, v := range []map[int32]uint8{nil, map[int32]uint8{}, map[int32]uint8{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v238: %v\n", v)
+		var v238v1, v238v2 map[int32]uint8
+		v238v1 = v
+		bs238, _ := testMarshalErr(v238v1, h, t, "enc-map-v238")
+		if v != nil {
+			v238v2 = make(map[int32]uint8, len(v))
+		}
+		testUnmarshalErr(v238v2, bs238, h, t, "dec-map-v238")
+		testDeepEqualErr(v238v1, v238v2, t, "equal-map-v238")
+		bs238, _ = testMarshalErr(&v238v1, h, t, "enc-map-v238-p")
+		v238v2 = nil
+		testUnmarshalErr(&v238v2, bs238, h, t, "dec-map-v238-p")
+		testDeepEqualErr(v238v1, v238v2, t, "equal-map-v238-p")
+	}
+
+	for _, v := range []map[int32]uint16{nil, map[int32]uint16{}, map[int32]uint16{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v239: %v\n", v)
+		var v239v1, v239v2 map[int32]uint16
+		v239v1 = v
+		bs239, _ := testMarshalErr(v239v1, h, t, "enc-map-v239")
+		if v != nil {
+			v239v2 = make(map[int32]uint16, len(v))
+		}
+		testUnmarshalErr(v239v2, bs239, h, t, "dec-map-v239")
+		testDeepEqualErr(v239v1, v239v2, t, "equal-map-v239")
+		bs239, _ = testMarshalErr(&v239v1, h, t, "enc-map-v239-p")
+		v239v2 = nil
+		testUnmarshalErr(&v239v2, bs239, h, t, "dec-map-v239-p")
+		testDeepEqualErr(v239v1, v239v2, t, "equal-map-v239-p")
+	}
+
+	for _, v := range []map[int32]uint32{nil, map[int32]uint32{}, map[int32]uint32{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v240: %v\n", v)
+		var v240v1, v240v2 map[int32]uint32
+		v240v1 = v
+		bs240, _ := testMarshalErr(v240v1, h, t, "enc-map-v240")
+		if v != nil {
+			v240v2 = make(map[int32]uint32, len(v))
+		}
+		testUnmarshalErr(v240v2, bs240, h, t, "dec-map-v240")
+		testDeepEqualErr(v240v1, v240v2, t, "equal-map-v240")
+		bs240, _ = testMarshalErr(&v240v1, h, t, "enc-map-v240-p")
+		v240v2 = nil
+		testUnmarshalErr(&v240v2, bs240, h, t, "dec-map-v240-p")
+		testDeepEqualErr(v240v1, v240v2, t, "equal-map-v240-p")
+	}
+
+	for _, v := range []map[int32]uint64{nil, map[int32]uint64{}, map[int32]uint64{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v241: %v\n", v)
+		var v241v1, v241v2 map[int32]uint64
+		v241v1 = v
+		bs241, _ := testMarshalErr(v241v1, h, t, "enc-map-v241")
+		if v != nil {
+			v241v2 = make(map[int32]uint64, len(v))
+		}
+		testUnmarshalErr(v241v2, bs241, h, t, "dec-map-v241")
+		testDeepEqualErr(v241v1, v241v2, t, "equal-map-v241")
+		bs241, _ = testMarshalErr(&v241v1, h, t, "enc-map-v241-p")
+		v241v2 = nil
+		testUnmarshalErr(&v241v2, bs241, h, t, "dec-map-v241-p")
+		testDeepEqualErr(v241v1, v241v2, t, "equal-map-v241-p")
+	}
+
+	for _, v := range []map[int32]uintptr{nil, map[int32]uintptr{}, map[int32]uintptr{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v242: %v\n", v)
+		var v242v1, v242v2 map[int32]uintptr
+		v242v1 = v
+		bs242, _ := testMarshalErr(v242v1, h, t, "enc-map-v242")
+		if v != nil {
+			v242v2 = make(map[int32]uintptr, len(v))
+		}
+		testUnmarshalErr(v242v2, bs242, h, t, "dec-map-v242")
+		testDeepEqualErr(v242v1, v242v2, t, "equal-map-v242")
+		bs242, _ = testMarshalErr(&v242v1, h, t, "enc-map-v242-p")
+		v242v2 = nil
+		testUnmarshalErr(&v242v2, bs242, h, t, "dec-map-v242-p")
+		testDeepEqualErr(v242v1, v242v2, t, "equal-map-v242-p")
+	}
+
+	for _, v := range []map[int32]int{nil, map[int32]int{}, map[int32]int{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v243: %v\n", v)
+		var v243v1, v243v2 map[int32]int
+		v243v1 = v
+		bs243, _ := testMarshalErr(v243v1, h, t, "enc-map-v243")
+		if v != nil {
+			v243v2 = make(map[int32]int, len(v))
+		}
+		testUnmarshalErr(v243v2, bs243, h, t, "dec-map-v243")
+		testDeepEqualErr(v243v1, v243v2, t, "equal-map-v243")
+		bs243, _ = testMarshalErr(&v243v1, h, t, "enc-map-v243-p")
+		v243v2 = nil
+		testUnmarshalErr(&v243v2, bs243, h, t, "dec-map-v243-p")
+		testDeepEqualErr(v243v1, v243v2, t, "equal-map-v243-p")
+	}
+
+	for _, v := range []map[int32]int8{nil, map[int32]int8{}, map[int32]int8{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v244: %v\n", v)
+		var v244v1, v244v2 map[int32]int8
+		v244v1 = v
+		bs244, _ := testMarshalErr(v244v1, h, t, "enc-map-v244")
+		if v != nil {
+			v244v2 = make(map[int32]int8, len(v))
+		}
+		testUnmarshalErr(v244v2, bs244, h, t, "dec-map-v244")
+		testDeepEqualErr(v244v1, v244v2, t, "equal-map-v244")
+		bs244, _ = testMarshalErr(&v244v1, h, t, "enc-map-v244-p")
+		v244v2 = nil
+		testUnmarshalErr(&v244v2, bs244, h, t, "dec-map-v244-p")
+		testDeepEqualErr(v244v1, v244v2, t, "equal-map-v244-p")
+	}
+
+	for _, v := range []map[int32]int16{nil, map[int32]int16{}, map[int32]int16{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v245: %v\n", v)
+		var v245v1, v245v2 map[int32]int16
+		v245v1 = v
+		bs245, _ := testMarshalErr(v245v1, h, t, "enc-map-v245")
+		if v != nil {
+			v245v2 = make(map[int32]int16, len(v))
+		}
+		testUnmarshalErr(v245v2, bs245, h, t, "dec-map-v245")
+		testDeepEqualErr(v245v1, v245v2, t, "equal-map-v245")
+		bs245, _ = testMarshalErr(&v245v1, h, t, "enc-map-v245-p")
+		v245v2 = nil
+		testUnmarshalErr(&v245v2, bs245, h, t, "dec-map-v245-p")
+		testDeepEqualErr(v245v1, v245v2, t, "equal-map-v245-p")
+	}
+
+	for _, v := range []map[int32]int32{nil, map[int32]int32{}, map[int32]int32{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v246: %v\n", v)
+		var v246v1, v246v2 map[int32]int32
+		v246v1 = v
+		bs246, _ := testMarshalErr(v246v1, h, t, "enc-map-v246")
+		if v != nil {
+			v246v2 = make(map[int32]int32, len(v))
+		}
+		testUnmarshalErr(v246v2, bs246, h, t, "dec-map-v246")
+		testDeepEqualErr(v246v1, v246v2, t, "equal-map-v246")
+		bs246, _ = testMarshalErr(&v246v1, h, t, "enc-map-v246-p")
+		v246v2 = nil
+		testUnmarshalErr(&v246v2, bs246, h, t, "dec-map-v246-p")
+		testDeepEqualErr(v246v1, v246v2, t, "equal-map-v246-p")
+	}
+
+	for _, v := range []map[int32]int64{nil, map[int32]int64{}, map[int32]int64{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v247: %v\n", v)
+		var v247v1, v247v2 map[int32]int64
+		v247v1 = v
+		bs247, _ := testMarshalErr(v247v1, h, t, "enc-map-v247")
+		if v != nil {
+			v247v2 = make(map[int32]int64, len(v))
+		}
+		testUnmarshalErr(v247v2, bs247, h, t, "dec-map-v247")
+		testDeepEqualErr(v247v1, v247v2, t, "equal-map-v247")
+		bs247, _ = testMarshalErr(&v247v1, h, t, "enc-map-v247-p")
+		v247v2 = nil
+		testUnmarshalErr(&v247v2, bs247, h, t, "dec-map-v247-p")
+		testDeepEqualErr(v247v1, v247v2, t, "equal-map-v247-p")
+	}
+
+	for _, v := range []map[int32]float32{nil, map[int32]float32{}, map[int32]float32{10: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v248: %v\n", v)
+		var v248v1, v248v2 map[int32]float32
+		v248v1 = v
+		bs248, _ := testMarshalErr(v248v1, h, t, "enc-map-v248")
+		if v != nil {
+			v248v2 = make(map[int32]float32, len(v))
+		}
+		testUnmarshalErr(v248v2, bs248, h, t, "dec-map-v248")
+		testDeepEqualErr(v248v1, v248v2, t, "equal-map-v248")
+		bs248, _ = testMarshalErr(&v248v1, h, t, "enc-map-v248-p")
+		v248v2 = nil
+		testUnmarshalErr(&v248v2, bs248, h, t, "dec-map-v248-p")
+		testDeepEqualErr(v248v1, v248v2, t, "equal-map-v248-p")
+	}
+
+	for _, v := range []map[int32]float64{nil, map[int32]float64{}, map[int32]float64{10: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v249: %v\n", v)
+		var v249v1, v249v2 map[int32]float64
+		v249v1 = v
+		bs249, _ := testMarshalErr(v249v1, h, t, "enc-map-v249")
+		if v != nil {
+			v249v2 = make(map[int32]float64, len(v))
+		}
+		testUnmarshalErr(v249v2, bs249, h, t, "dec-map-v249")
+		testDeepEqualErr(v249v1, v249v2, t, "equal-map-v249")
+		bs249, _ = testMarshalErr(&v249v1, h, t, "enc-map-v249-p")
+		v249v2 = nil
+		testUnmarshalErr(&v249v2, bs249, h, t, "dec-map-v249-p")
+		testDeepEqualErr(v249v1, v249v2, t, "equal-map-v249-p")
+	}
+
+	for _, v := range []map[int32]bool{nil, map[int32]bool{}, map[int32]bool{10: true}} {
+		// fmt.Printf(">>>> running mammoth map v250: %v\n", v)
+		var v250v1, v250v2 map[int32]bool
+		v250v1 = v
+		bs250, _ := testMarshalErr(v250v1, h, t, "enc-map-v250")
+		if v != nil {
+			v250v2 = make(map[int32]bool, len(v))
+		}
+		testUnmarshalErr(v250v2, bs250, h, t, "dec-map-v250")
+		testDeepEqualErr(v250v1, v250v2, t, "equal-map-v250")
+		bs250, _ = testMarshalErr(&v250v1, h, t, "enc-map-v250-p")
+		v250v2 = nil
+		testUnmarshalErr(&v250v2, bs250, h, t, "dec-map-v250-p")
+		testDeepEqualErr(v250v1, v250v2, t, "equal-map-v250-p")
+	}
+
+	for _, v := range []map[int64]interface{}{nil, map[int64]interface{}{}, map[int64]interface{}{10: "string-is-an-interface"}} {
+		// fmt.Printf(">>>> running mammoth map v253: %v\n", v)
+		var v253v1, v253v2 map[int64]interface{}
+		v253v1 = v
+		bs253, _ := testMarshalErr(v253v1, h, t, "enc-map-v253")
+		if v != nil {
+			v253v2 = make(map[int64]interface{}, len(v))
+		}
+		testUnmarshalErr(v253v2, bs253, h, t, "dec-map-v253")
+		testDeepEqualErr(v253v1, v253v2, t, "equal-map-v253")
+		bs253, _ = testMarshalErr(&v253v1, h, t, "enc-map-v253-p")
+		v253v2 = nil
+		testUnmarshalErr(&v253v2, bs253, h, t, "dec-map-v253-p")
+		testDeepEqualErr(v253v1, v253v2, t, "equal-map-v253-p")
+	}
+
+	for _, v := range []map[int64]string{nil, map[int64]string{}, map[int64]string{10: "some-string"}} {
+		// fmt.Printf(">>>> running mammoth map v254: %v\n", v)
+		var v254v1, v254v2 map[int64]string
+		v254v1 = v
+		bs254, _ := testMarshalErr(v254v1, h, t, "enc-map-v254")
+		if v != nil {
+			v254v2 = make(map[int64]string, len(v))
+		}
+		testUnmarshalErr(v254v2, bs254, h, t, "dec-map-v254")
+		testDeepEqualErr(v254v1, v254v2, t, "equal-map-v254")
+		bs254, _ = testMarshalErr(&v254v1, h, t, "enc-map-v254-p")
+		v254v2 = nil
+		testUnmarshalErr(&v254v2, bs254, h, t, "dec-map-v254-p")
+		testDeepEqualErr(v254v1, v254v2, t, "equal-map-v254-p")
+	}
+
+	for _, v := range []map[int64]uint{nil, map[int64]uint{}, map[int64]uint{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v255: %v\n", v)
+		var v255v1, v255v2 map[int64]uint
+		v255v1 = v
+		bs255, _ := testMarshalErr(v255v1, h, t, "enc-map-v255")
+		if v != nil {
+			v255v2 = make(map[int64]uint, len(v))
+		}
+		testUnmarshalErr(v255v2, bs255, h, t, "dec-map-v255")
+		testDeepEqualErr(v255v1, v255v2, t, "equal-map-v255")
+		bs255, _ = testMarshalErr(&v255v1, h, t, "enc-map-v255-p")
+		v255v2 = nil
+		testUnmarshalErr(&v255v2, bs255, h, t, "dec-map-v255-p")
+		testDeepEqualErr(v255v1, v255v2, t, "equal-map-v255-p")
+	}
+
+	for _, v := range []map[int64]uint8{nil, map[int64]uint8{}, map[int64]uint8{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v256: %v\n", v)
+		var v256v1, v256v2 map[int64]uint8
+		v256v1 = v
+		bs256, _ := testMarshalErr(v256v1, h, t, "enc-map-v256")
+		if v != nil {
+			v256v2 = make(map[int64]uint8, len(v))
+		}
+		testUnmarshalErr(v256v2, bs256, h, t, "dec-map-v256")
+		testDeepEqualErr(v256v1, v256v2, t, "equal-map-v256")
+		bs256, _ = testMarshalErr(&v256v1, h, t, "enc-map-v256-p")
+		v256v2 = nil
+		testUnmarshalErr(&v256v2, bs256, h, t, "dec-map-v256-p")
+		testDeepEqualErr(v256v1, v256v2, t, "equal-map-v256-p")
+	}
+
+	for _, v := range []map[int64]uint16{nil, map[int64]uint16{}, map[int64]uint16{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v257: %v\n", v)
+		var v257v1, v257v2 map[int64]uint16
+		v257v1 = v
+		bs257, _ := testMarshalErr(v257v1, h, t, "enc-map-v257")
+		if v != nil {
+			v257v2 = make(map[int64]uint16, len(v))
+		}
+		testUnmarshalErr(v257v2, bs257, h, t, "dec-map-v257")
+		testDeepEqualErr(v257v1, v257v2, t, "equal-map-v257")
+		bs257, _ = testMarshalErr(&v257v1, h, t, "enc-map-v257-p")
+		v257v2 = nil
+		testUnmarshalErr(&v257v2, bs257, h, t, "dec-map-v257-p")
+		testDeepEqualErr(v257v1, v257v2, t, "equal-map-v257-p")
+	}
+
+	for _, v := range []map[int64]uint32{nil, map[int64]uint32{}, map[int64]uint32{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v258: %v\n", v)
+		var v258v1, v258v2 map[int64]uint32
+		v258v1 = v
+		bs258, _ := testMarshalErr(v258v1, h, t, "enc-map-v258")
+		if v != nil {
+			v258v2 = make(map[int64]uint32, len(v))
+		}
+		testUnmarshalErr(v258v2, bs258, h, t, "dec-map-v258")
+		testDeepEqualErr(v258v1, v258v2, t, "equal-map-v258")
+		bs258, _ = testMarshalErr(&v258v1, h, t, "enc-map-v258-p")
+		v258v2 = nil
+		testUnmarshalErr(&v258v2, bs258, h, t, "dec-map-v258-p")
+		testDeepEqualErr(v258v1, v258v2, t, "equal-map-v258-p")
+	}
+
+	for _, v := range []map[int64]uint64{nil, map[int64]uint64{}, map[int64]uint64{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v259: %v\n", v)
+		var v259v1, v259v2 map[int64]uint64
+		v259v1 = v
+		bs259, _ := testMarshalErr(v259v1, h, t, "enc-map-v259")
+		if v != nil {
+			v259v2 = make(map[int64]uint64, len(v))
+		}
+		testUnmarshalErr(v259v2, bs259, h, t, "dec-map-v259")
+		testDeepEqualErr(v259v1, v259v2, t, "equal-map-v259")
+		bs259, _ = testMarshalErr(&v259v1, h, t, "enc-map-v259-p")
+		v259v2 = nil
+		testUnmarshalErr(&v259v2, bs259, h, t, "dec-map-v259-p")
+		testDeepEqualErr(v259v1, v259v2, t, "equal-map-v259-p")
+	}
+
+	for _, v := range []map[int64]uintptr{nil, map[int64]uintptr{}, map[int64]uintptr{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v260: %v\n", v)
+		var v260v1, v260v2 map[int64]uintptr
+		v260v1 = v
+		bs260, _ := testMarshalErr(v260v1, h, t, "enc-map-v260")
+		if v != nil {
+			v260v2 = make(map[int64]uintptr, len(v))
+		}
+		testUnmarshalErr(v260v2, bs260, h, t, "dec-map-v260")
+		testDeepEqualErr(v260v1, v260v2, t, "equal-map-v260")
+		bs260, _ = testMarshalErr(&v260v1, h, t, "enc-map-v260-p")
+		v260v2 = nil
+		testUnmarshalErr(&v260v2, bs260, h, t, "dec-map-v260-p")
+		testDeepEqualErr(v260v1, v260v2, t, "equal-map-v260-p")
+	}
+
+	for _, v := range []map[int64]int{nil, map[int64]int{}, map[int64]int{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v261: %v\n", v)
+		var v261v1, v261v2 map[int64]int
+		v261v1 = v
+		bs261, _ := testMarshalErr(v261v1, h, t, "enc-map-v261")
+		if v != nil {
+			v261v2 = make(map[int64]int, len(v))
+		}
+		testUnmarshalErr(v261v2, bs261, h, t, "dec-map-v261")
+		testDeepEqualErr(v261v1, v261v2, t, "equal-map-v261")
+		bs261, _ = testMarshalErr(&v261v1, h, t, "enc-map-v261-p")
+		v261v2 = nil
+		testUnmarshalErr(&v261v2, bs261, h, t, "dec-map-v261-p")
+		testDeepEqualErr(v261v1, v261v2, t, "equal-map-v261-p")
+	}
+
+	for _, v := range []map[int64]int8{nil, map[int64]int8{}, map[int64]int8{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v262: %v\n", v)
+		var v262v1, v262v2 map[int64]int8
+		v262v1 = v
+		bs262, _ := testMarshalErr(v262v1, h, t, "enc-map-v262")
+		if v != nil {
+			v262v2 = make(map[int64]int8, len(v))
+		}
+		testUnmarshalErr(v262v2, bs262, h, t, "dec-map-v262")
+		testDeepEqualErr(v262v1, v262v2, t, "equal-map-v262")
+		bs262, _ = testMarshalErr(&v262v1, h, t, "enc-map-v262-p")
+		v262v2 = nil
+		testUnmarshalErr(&v262v2, bs262, h, t, "dec-map-v262-p")
+		testDeepEqualErr(v262v1, v262v2, t, "equal-map-v262-p")
+	}
+
+	for _, v := range []map[int64]int16{nil, map[int64]int16{}, map[int64]int16{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v263: %v\n", v)
+		var v263v1, v263v2 map[int64]int16
+		v263v1 = v
+		bs263, _ := testMarshalErr(v263v1, h, t, "enc-map-v263")
+		if v != nil {
+			v263v2 = make(map[int64]int16, len(v))
+		}
+		testUnmarshalErr(v263v2, bs263, h, t, "dec-map-v263")
+		testDeepEqualErr(v263v1, v263v2, t, "equal-map-v263")
+		bs263, _ = testMarshalErr(&v263v1, h, t, "enc-map-v263-p")
+		v263v2 = nil
+		testUnmarshalErr(&v263v2, bs263, h, t, "dec-map-v263-p")
+		testDeepEqualErr(v263v1, v263v2, t, "equal-map-v263-p")
+	}
+
+	for _, v := range []map[int64]int32{nil, map[int64]int32{}, map[int64]int32{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v264: %v\n", v)
+		var v264v1, v264v2 map[int64]int32
+		v264v1 = v
+		bs264, _ := testMarshalErr(v264v1, h, t, "enc-map-v264")
+		if v != nil {
+			v264v2 = make(map[int64]int32, len(v))
+		}
+		testUnmarshalErr(v264v2, bs264, h, t, "dec-map-v264")
+		testDeepEqualErr(v264v1, v264v2, t, "equal-map-v264")
+		bs264, _ = testMarshalErr(&v264v1, h, t, "enc-map-v264-p")
+		v264v2 = nil
+		testUnmarshalErr(&v264v2, bs264, h, t, "dec-map-v264-p")
+		testDeepEqualErr(v264v1, v264v2, t, "equal-map-v264-p")
+	}
+
+	for _, v := range []map[int64]int64{nil, map[int64]int64{}, map[int64]int64{10: 10}} {
+		// fmt.Printf(">>>> running mammoth map v265: %v\n", v)
+		var v265v1, v265v2 map[int64]int64
+		v265v1 = v
+		bs265, _ := testMarshalErr(v265v1, h, t, "enc-map-v265")
+		if v != nil {
+			v265v2 = make(map[int64]int64, len(v))
+		}
+		testUnmarshalErr(v265v2, bs265, h, t, "dec-map-v265")
+		testDeepEqualErr(v265v1, v265v2, t, "equal-map-v265")
+		bs265, _ = testMarshalErr(&v265v1, h, t, "enc-map-v265-p")
+		v265v2 = nil
+		testUnmarshalErr(&v265v2, bs265, h, t, "dec-map-v265-p")
+		testDeepEqualErr(v265v1, v265v2, t, "equal-map-v265-p")
+	}
+
+	for _, v := range []map[int64]float32{nil, map[int64]float32{}, map[int64]float32{10: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v266: %v\n", v)
+		var v266v1, v266v2 map[int64]float32
+		v266v1 = v
+		bs266, _ := testMarshalErr(v266v1, h, t, "enc-map-v266")
+		if v != nil {
+			v266v2 = make(map[int64]float32, len(v))
+		}
+		testUnmarshalErr(v266v2, bs266, h, t, "dec-map-v266")
+		testDeepEqualErr(v266v1, v266v2, t, "equal-map-v266")
+		bs266, _ = testMarshalErr(&v266v1, h, t, "enc-map-v266-p")
+		v266v2 = nil
+		testUnmarshalErr(&v266v2, bs266, h, t, "dec-map-v266-p")
+		testDeepEqualErr(v266v1, v266v2, t, "equal-map-v266-p")
+	}
+
+	for _, v := range []map[int64]float64{nil, map[int64]float64{}, map[int64]float64{10: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v267: %v\n", v)
+		var v267v1, v267v2 map[int64]float64
+		v267v1 = v
+		bs267, _ := testMarshalErr(v267v1, h, t, "enc-map-v267")
+		if v != nil {
+			v267v2 = make(map[int64]float64, len(v))
+		}
+		testUnmarshalErr(v267v2, bs267, h, t, "dec-map-v267")
+		testDeepEqualErr(v267v1, v267v2, t, "equal-map-v267")
+		bs267, _ = testMarshalErr(&v267v1, h, t, "enc-map-v267-p")
+		v267v2 = nil
+		testUnmarshalErr(&v267v2, bs267, h, t, "dec-map-v267-p")
+		testDeepEqualErr(v267v1, v267v2, t, "equal-map-v267-p")
+	}
+
+	for _, v := range []map[int64]bool{nil, map[int64]bool{}, map[int64]bool{10: true}} {
+		// fmt.Printf(">>>> running mammoth map v268: %v\n", v)
+		var v268v1, v268v2 map[int64]bool
+		v268v1 = v
+		bs268, _ := testMarshalErr(v268v1, h, t, "enc-map-v268")
+		if v != nil {
+			v268v2 = make(map[int64]bool, len(v))
+		}
+		testUnmarshalErr(v268v2, bs268, h, t, "dec-map-v268")
+		testDeepEqualErr(v268v1, v268v2, t, "equal-map-v268")
+		bs268, _ = testMarshalErr(&v268v1, h, t, "enc-map-v268-p")
+		v268v2 = nil
+		testUnmarshalErr(&v268v2, bs268, h, t, "dec-map-v268-p")
+		testDeepEqualErr(v268v1, v268v2, t, "equal-map-v268-p")
+	}
+
+	for _, v := range []map[bool]interface{}{nil, map[bool]interface{}{}, map[bool]interface{}{true: "string-is-an-interface"}} {
+		// fmt.Printf(">>>> running mammoth map v271: %v\n", v)
+		var v271v1, v271v2 map[bool]interface{}
+		v271v1 = v
+		bs271, _ := testMarshalErr(v271v1, h, t, "enc-map-v271")
+		if v != nil {
+			v271v2 = make(map[bool]interface{}, len(v))
+		}
+		testUnmarshalErr(v271v2, bs271, h, t, "dec-map-v271")
+		testDeepEqualErr(v271v1, v271v2, t, "equal-map-v271")
+		bs271, _ = testMarshalErr(&v271v1, h, t, "enc-map-v271-p")
+		v271v2 = nil
+		testUnmarshalErr(&v271v2, bs271, h, t, "dec-map-v271-p")
+		testDeepEqualErr(v271v1, v271v2, t, "equal-map-v271-p")
+	}
+
+	for _, v := range []map[bool]string{nil, map[bool]string{}, map[bool]string{true: "some-string"}} {
+		// fmt.Printf(">>>> running mammoth map v272: %v\n", v)
+		var v272v1, v272v2 map[bool]string
+		v272v1 = v
+		bs272, _ := testMarshalErr(v272v1, h, t, "enc-map-v272")
+		if v != nil {
+			v272v2 = make(map[bool]string, len(v))
+		}
+		testUnmarshalErr(v272v2, bs272, h, t, "dec-map-v272")
+		testDeepEqualErr(v272v1, v272v2, t, "equal-map-v272")
+		bs272, _ = testMarshalErr(&v272v1, h, t, "enc-map-v272-p")
+		v272v2 = nil
+		testUnmarshalErr(&v272v2, bs272, h, t, "dec-map-v272-p")
+		testDeepEqualErr(v272v1, v272v2, t, "equal-map-v272-p")
+	}
+
+	for _, v := range []map[bool]uint{nil, map[bool]uint{}, map[bool]uint{true: 10}} {
+		// fmt.Printf(">>>> running mammoth map v273: %v\n", v)
+		var v273v1, v273v2 map[bool]uint
+		v273v1 = v
+		bs273, _ := testMarshalErr(v273v1, h, t, "enc-map-v273")
+		if v != nil {
+			v273v2 = make(map[bool]uint, len(v))
+		}
+		testUnmarshalErr(v273v2, bs273, h, t, "dec-map-v273")
+		testDeepEqualErr(v273v1, v273v2, t, "equal-map-v273")
+		bs273, _ = testMarshalErr(&v273v1, h, t, "enc-map-v273-p")
+		v273v2 = nil
+		testUnmarshalErr(&v273v2, bs273, h, t, "dec-map-v273-p")
+		testDeepEqualErr(v273v1, v273v2, t, "equal-map-v273-p")
+	}
+
+	for _, v := range []map[bool]uint8{nil, map[bool]uint8{}, map[bool]uint8{true: 10}} {
+		// fmt.Printf(">>>> running mammoth map v274: %v\n", v)
+		var v274v1, v274v2 map[bool]uint8
+		v274v1 = v
+		bs274, _ := testMarshalErr(v274v1, h, t, "enc-map-v274")
+		if v != nil {
+			v274v2 = make(map[bool]uint8, len(v))
+		}
+		testUnmarshalErr(v274v2, bs274, h, t, "dec-map-v274")
+		testDeepEqualErr(v274v1, v274v2, t, "equal-map-v274")
+		bs274, _ = testMarshalErr(&v274v1, h, t, "enc-map-v274-p")
+		v274v2 = nil
+		testUnmarshalErr(&v274v2, bs274, h, t, "dec-map-v274-p")
+		testDeepEqualErr(v274v1, v274v2, t, "equal-map-v274-p")
+	}
+
+	for _, v := range []map[bool]uint16{nil, map[bool]uint16{}, map[bool]uint16{true: 10}} {
+		// fmt.Printf(">>>> running mammoth map v275: %v\n", v)
+		var v275v1, v275v2 map[bool]uint16
+		v275v1 = v
+		bs275, _ := testMarshalErr(v275v1, h, t, "enc-map-v275")
+		if v != nil {
+			v275v2 = make(map[bool]uint16, len(v))
+		}
+		testUnmarshalErr(v275v2, bs275, h, t, "dec-map-v275")
+		testDeepEqualErr(v275v1, v275v2, t, "equal-map-v275")
+		bs275, _ = testMarshalErr(&v275v1, h, t, "enc-map-v275-p")
+		v275v2 = nil
+		testUnmarshalErr(&v275v2, bs275, h, t, "dec-map-v275-p")
+		testDeepEqualErr(v275v1, v275v2, t, "equal-map-v275-p")
+	}
+
+	for _, v := range []map[bool]uint32{nil, map[bool]uint32{}, map[bool]uint32{true: 10}} {
+		// fmt.Printf(">>>> running mammoth map v276: %v\n", v)
+		var v276v1, v276v2 map[bool]uint32
+		v276v1 = v
+		bs276, _ := testMarshalErr(v276v1, h, t, "enc-map-v276")
+		if v != nil {
+			v276v2 = make(map[bool]uint32, len(v))
+		}
+		testUnmarshalErr(v276v2, bs276, h, t, "dec-map-v276")
+		testDeepEqualErr(v276v1, v276v2, t, "equal-map-v276")
+		bs276, _ = testMarshalErr(&v276v1, h, t, "enc-map-v276-p")
+		v276v2 = nil
+		testUnmarshalErr(&v276v2, bs276, h, t, "dec-map-v276-p")
+		testDeepEqualErr(v276v1, v276v2, t, "equal-map-v276-p")
+	}
+
+	for _, v := range []map[bool]uint64{nil, map[bool]uint64{}, map[bool]uint64{true: 10}} {
+		// fmt.Printf(">>>> running mammoth map v277: %v\n", v)
+		var v277v1, v277v2 map[bool]uint64
+		v277v1 = v
+		bs277, _ := testMarshalErr(v277v1, h, t, "enc-map-v277")
+		if v != nil {
+			v277v2 = make(map[bool]uint64, len(v))
+		}
+		testUnmarshalErr(v277v2, bs277, h, t, "dec-map-v277")
+		testDeepEqualErr(v277v1, v277v2, t, "equal-map-v277")
+		bs277, _ = testMarshalErr(&v277v1, h, t, "enc-map-v277-p")
+		v277v2 = nil
+		testUnmarshalErr(&v277v2, bs277, h, t, "dec-map-v277-p")
+		testDeepEqualErr(v277v1, v277v2, t, "equal-map-v277-p")
+	}
+
+	for _, v := range []map[bool]uintptr{nil, map[bool]uintptr{}, map[bool]uintptr{true: 10}} {
+		// fmt.Printf(">>>> running mammoth map v278: %v\n", v)
+		var v278v1, v278v2 map[bool]uintptr
+		v278v1 = v
+		bs278, _ := testMarshalErr(v278v1, h, t, "enc-map-v278")
+		if v != nil {
+			v278v2 = make(map[bool]uintptr, len(v))
+		}
+		testUnmarshalErr(v278v2, bs278, h, t, "dec-map-v278")
+		testDeepEqualErr(v278v1, v278v2, t, "equal-map-v278")
+		bs278, _ = testMarshalErr(&v278v1, h, t, "enc-map-v278-p")
+		v278v2 = nil
+		testUnmarshalErr(&v278v2, bs278, h, t, "dec-map-v278-p")
+		testDeepEqualErr(v278v1, v278v2, t, "equal-map-v278-p")
+	}
+
+	for _, v := range []map[bool]int{nil, map[bool]int{}, map[bool]int{true: 10}} {
+		// fmt.Printf(">>>> running mammoth map v279: %v\n", v)
+		var v279v1, v279v2 map[bool]int
+		v279v1 = v
+		bs279, _ := testMarshalErr(v279v1, h, t, "enc-map-v279")
+		if v != nil {
+			v279v2 = make(map[bool]int, len(v))
+		}
+		testUnmarshalErr(v279v2, bs279, h, t, "dec-map-v279")
+		testDeepEqualErr(v279v1, v279v2, t, "equal-map-v279")
+		bs279, _ = testMarshalErr(&v279v1, h, t, "enc-map-v279-p")
+		v279v2 = nil
+		testUnmarshalErr(&v279v2, bs279, h, t, "dec-map-v279-p")
+		testDeepEqualErr(v279v1, v279v2, t, "equal-map-v279-p")
+	}
+
+	for _, v := range []map[bool]int8{nil, map[bool]int8{}, map[bool]int8{true: 10}} {
+		// fmt.Printf(">>>> running mammoth map v280: %v\n", v)
+		var v280v1, v280v2 map[bool]int8
+		v280v1 = v
+		bs280, _ := testMarshalErr(v280v1, h, t, "enc-map-v280")
+		if v != nil {
+			v280v2 = make(map[bool]int8, len(v))
+		}
+		testUnmarshalErr(v280v2, bs280, h, t, "dec-map-v280")
+		testDeepEqualErr(v280v1, v280v2, t, "equal-map-v280")
+		bs280, _ = testMarshalErr(&v280v1, h, t, "enc-map-v280-p")
+		v280v2 = nil
+		testUnmarshalErr(&v280v2, bs280, h, t, "dec-map-v280-p")
+		testDeepEqualErr(v280v1, v280v2, t, "equal-map-v280-p")
+	}
+
+	for _, v := range []map[bool]int16{nil, map[bool]int16{}, map[bool]int16{true: 10}} {
+		// fmt.Printf(">>>> running mammoth map v281: %v\n", v)
+		var v281v1, v281v2 map[bool]int16
+		v281v1 = v
+		bs281, _ := testMarshalErr(v281v1, h, t, "enc-map-v281")
+		if v != nil {
+			v281v2 = make(map[bool]int16, len(v))
+		}
+		testUnmarshalErr(v281v2, bs281, h, t, "dec-map-v281")
+		testDeepEqualErr(v281v1, v281v2, t, "equal-map-v281")
+		bs281, _ = testMarshalErr(&v281v1, h, t, "enc-map-v281-p")
+		v281v2 = nil
+		testUnmarshalErr(&v281v2, bs281, h, t, "dec-map-v281-p")
+		testDeepEqualErr(v281v1, v281v2, t, "equal-map-v281-p")
+	}
+
+	for _, v := range []map[bool]int32{nil, map[bool]int32{}, map[bool]int32{true: 10}} {
+		// fmt.Printf(">>>> running mammoth map v282: %v\n", v)
+		var v282v1, v282v2 map[bool]int32
+		v282v1 = v
+		bs282, _ := testMarshalErr(v282v1, h, t, "enc-map-v282")
+		if v != nil {
+			v282v2 = make(map[bool]int32, len(v))
+		}
+		testUnmarshalErr(v282v2, bs282, h, t, "dec-map-v282")
+		testDeepEqualErr(v282v1, v282v2, t, "equal-map-v282")
+		bs282, _ = testMarshalErr(&v282v1, h, t, "enc-map-v282-p")
+		v282v2 = nil
+		testUnmarshalErr(&v282v2, bs282, h, t, "dec-map-v282-p")
+		testDeepEqualErr(v282v1, v282v2, t, "equal-map-v282-p")
+	}
+
+	for _, v := range []map[bool]int64{nil, map[bool]int64{}, map[bool]int64{true: 10}} {
+		// fmt.Printf(">>>> running mammoth map v283: %v\n", v)
+		var v283v1, v283v2 map[bool]int64
+		v283v1 = v
+		bs283, _ := testMarshalErr(v283v1, h, t, "enc-map-v283")
+		if v != nil {
+			v283v2 = make(map[bool]int64, len(v))
+		}
+		testUnmarshalErr(v283v2, bs283, h, t, "dec-map-v283")
+		testDeepEqualErr(v283v1, v283v2, t, "equal-map-v283")
+		bs283, _ = testMarshalErr(&v283v1, h, t, "enc-map-v283-p")
+		v283v2 = nil
+		testUnmarshalErr(&v283v2, bs283, h, t, "dec-map-v283-p")
+		testDeepEqualErr(v283v1, v283v2, t, "equal-map-v283-p")
+	}
+
+	for _, v := range []map[bool]float32{nil, map[bool]float32{}, map[bool]float32{true: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v284: %v\n", v)
+		var v284v1, v284v2 map[bool]float32
+		v284v1 = v
+		bs284, _ := testMarshalErr(v284v1, h, t, "enc-map-v284")
+		if v != nil {
+			v284v2 = make(map[bool]float32, len(v))
+		}
+		testUnmarshalErr(v284v2, bs284, h, t, "dec-map-v284")
+		testDeepEqualErr(v284v1, v284v2, t, "equal-map-v284")
+		bs284, _ = testMarshalErr(&v284v1, h, t, "enc-map-v284-p")
+		v284v2 = nil
+		testUnmarshalErr(&v284v2, bs284, h, t, "dec-map-v284-p")
+		testDeepEqualErr(v284v1, v284v2, t, "equal-map-v284-p")
+	}
+
+	for _, v := range []map[bool]float64{nil, map[bool]float64{}, map[bool]float64{true: 10.1}} {
+		// fmt.Printf(">>>> running mammoth map v285: %v\n", v)
+		var v285v1, v285v2 map[bool]float64
+		v285v1 = v
+		bs285, _ := testMarshalErr(v285v1, h, t, "enc-map-v285")
+		if v != nil {
+			v285v2 = make(map[bool]float64, len(v))
+		}
+		testUnmarshalErr(v285v2, bs285, h, t, "dec-map-v285")
+		testDeepEqualErr(v285v1, v285v2, t, "equal-map-v285")
+		bs285, _ = testMarshalErr(&v285v1, h, t, "enc-map-v285-p")
+		v285v2 = nil
+		testUnmarshalErr(&v285v2, bs285, h, t, "dec-map-v285-p")
+		testDeepEqualErr(v285v1, v285v2, t, "equal-map-v285-p")
+	}
+
+	for _, v := range []map[bool]bool{nil, map[bool]bool{}, map[bool]bool{true: true}} {
+		// fmt.Printf(">>>> running mammoth map v286: %v\n", v)
+		var v286v1, v286v2 map[bool]bool
+		v286v1 = v
+		bs286, _ := testMarshalErr(v286v1, h, t, "enc-map-v286")
+		if v != nil {
+			v286v2 = make(map[bool]bool, len(v))
+		}
+		testUnmarshalErr(v286v2, bs286, h, t, "dec-map-v286")
+		testDeepEqualErr(v286v1, v286v2, t, "equal-map-v286")
+		bs286, _ = testMarshalErr(&v286v1, h, t, "enc-map-v286-p")
+		v286v2 = nil
+		testUnmarshalErr(&v286v2, bs286, h, t, "dec-map-v286-p")
+		testDeepEqualErr(v286v1, v286v2, t, "equal-map-v286-p")
+	}
 
 }
 

codec/z_all_test.go

@@ -68,6 +68,7 @@ func testSuite(t *testing.T, f func(t *testing.T)) {
 	testReinit()
 	t.Run("optionsTrue", f)
 
+	testEncodeOptions.AsSymbols = AsSymbolAll
 	testUseIoWrapper = true
 	testReinit()
 	t.Run("optionsTrue-ioWrapper", f)
@@ -317,17 +318,12 @@ func TestCodecSuite(t *testing.T) {
 	testGroupResetFlags()
 }
 
-// func TestCodecSuite(t *testing.T) { testSuite2(t, testCodecGroup2) }
-// func testCodecGroup2(t *testing.T) {
-// 	t.Run("TestJsonCodecsTable", TestJsonCodecsTable)
-// 	t.Run("TestJsonCodecsMisc", TestJsonCodecsMisc)
-// }
-// func testSuite2(t *testing.T, f func(t *testing.T)) {
-// 	testUseIoEncDec = true
-// 	testDecodeOptions = DecodeOptions{}
-// 	testEncodeOptions = EncodeOptions{}
-// 	testDecodeOptions.ReaderBufferSize = 128
-// 	testEncodeOptions.WriterBufferSize = 128
+// func TestCodecSuite(t *testing.T) {
+// 	testReinit() // so flag.Parse() is called first, and never called again
+// 	testDecodeOptions, testEncodeOptions = DecodeOptions{}, EncodeOptions{}
+// 	testGroupResetFlags()
 // 	testReinit()
-// 	t.Run("optionsTrue-bufio", f)
+// 	t.Run("optionsFalse", func(t *testing.T) {
+// 		t.Run("TestJsonMammothMapsAndSlices", TestJsonMammothMapsAndSlices)
+// 	})
 // }