diff --git a/vendor/github.com/ugorji/go/codec/0doc.go b/vendor/github.com/ugorji/go/codec/0doc.go
index 11a9753a2..0c692f9fb 100644
--- a/vendor/github.com/ugorji/go/codec/0doc.go
+++ b/vendor/github.com/ugorji/go/codec/0doc.go
@@ -2,8 +2,9 @@
 // Use of this source code is governed by a MIT license found in the LICENSE file.
 
 /*
-High Performance, Feature-Rich Idiomatic Go 1.4+ codec/encoding library for
-binc, msgpack, cbor, json
+Package codec provides a
+High Performance, Feature-Rich Idiomatic Go 1.4+ codec/encoding library
+for binc, msgpack, cbor, json.
 
 Supported Serialization formats are:
 
@@ -31,8 +32,13 @@ the standard library (ie json, xml, gob, etc).
 Rich Feature Set includes:
 
   - Simple but extremely powerful and feature-rich API
+  - Support for go1.4 and above, while selectively using newer APIs for later releases
+  - Excellent code coverage ( > 90% )
   - Very High Performance.
     Our extensive benchmarks show us outperforming Gob, Json, Bson, etc by 2-4X.
+  - Careful selected use of 'unsafe' for targeted performance gains.
+    100% mode exists where 'unsafe' is not used at all.
+  - Lock-free (sans mutex) concurrency for scaling to 100's of cores
   - Multiple conversions:
     Package coerces types where appropriate
     e.g. decode an int in the stream into a float, etc.
@@ -48,6 +54,8 @@ Rich Feature Set includes:
     Includes Options to configure what specific map or slice type to use
     when decoding an encoded list or map into a nil interface{}
   - Encode a struct as an array, and decode struct from an array in the data stream
+  - Option to encode struct keys as numbers (instead of strings)
+    (to support structured streams with fields encoded as numeric codes)
   - Comprehensive support for anonymous fields
   - Fast (no-reflection) encoding/decoding of common maps and slices
   - Code-generation for faster performance.
@@ -88,6 +96,27 @@ encoded as an empty map because it has no exported fields, while UUID
 would be encoded as a string. However, with extension support, you can
 encode any of these however you like.
 
+Custom Encoding and Decoding
+
+This package maintains symmetry in the encoding and decoding halfs.
+We determine how to encode or decode by walking this decision tree
+
+  - is type a codec.Selfer?
+  - is there an extension registered for the type?
+  - is format binary, and is type a encoding.BinaryMarshaler and BinaryUnmarshaler?
+  - is format specifically json, and is type a encoding/json.Marshaler and Unmarshaler?
+  - is format text-based, and type an encoding.TextMarshaler?
+  - else we use a pair of functions based on the "kind" of the type e.g. map, slice, int64, etc
+
+This symmetry is important to reduce chances of issues happening because the
+encoding and decoding sides are out of sync e.g. decoded via very specific
+encoding.TextUnmarshaler but encoded via kind-specific generalized mode.
+
+Consequently, if a type only defines one-half of the symmetry
+(e.g. it implements UnmarshalJSON() but not MarshalJSON() ),
+then that type doesn't satisfy the check and we will continue walking down the
+decision tree.
+
 RPC
 
 RPC Client and Server Codecs are implemented, so the codecs can be used
@@ -156,40 +185,51 @@ Sample usage model:
     //OR rpcCodec := codec.MsgpackSpecRpc.ClientCodec(conn, h)
     client := rpc.NewClientWithCodec(rpcCodec)
 
+Running Tests
+
+To run tests, use the following:
+
+    go test
+
+To run the full suite of tests, use the following:
+
+    go test -tags alltests -run Suite
+
+You can run the tag 'safe' to run tests or build in safe mode. e.g.
+
+    go test -tags safe -run Json
+    go test -tags "alltests safe" -run Suite
+
+Running Benchmarks
+
+Please see http://github.com/ugorji/go-codec-bench .
+
+Caveats
+
+Struct fields matching the following are ignored during encoding and decoding
+    - struct tag value set to -
+    - func, complex numbers, unsafe pointers
+    - unexported and not embedded
+    - unexported embedded non-struct
+    - unexported embedded pointers (from go1.10)
+
+Every other field in a struct will be encoded/decoded.
+
+Embedded fields are encoded as if they exist in the top-level struct,
+with some caveats. See Encode documentation.
+
 */
 package codec
 
-// Benefits of go-codec:
-//
-//    - encoding/json always reads whole file into memory first.
-//      This makes it unsuitable for parsing very large files.
-//    - encoding/xml cannot parse into a map[string]interface{}
-//      I found this out on reading https://github.com/clbanning/mxj
-
 // TODO:
-//
-//   - optimization for codecgen:
-//     if len of entity is <= 3 words, then support a value receiver for encode.
-//   - (En|De)coder should store an error when it occurs.
-//     Until reset, subsequent calls return that error that was stored.
-//     This means that free panics must go away.
-//     All errors must be raised through errorf method.
-//   - Decoding using a chan is good, but incurs concurrency costs.
-//     This is because there's no fast way to use a channel without it
-//     having to switch goroutines constantly.
-//     Callback pattern is still the best. Maybe consider supporting something like:
-//        type X struct {
-//             Name string
-//             Ys []Y
-//             Ys chan <- Y
-//             Ys func(Y) -> call this function for each entry
-//        }
-//    - Consider adding a isZeroer interface { isZero() bool }
-//      It is used within isEmpty, for omitEmpty support.
-//    - Consider making Handle used AS-IS within the encoding/decoding session.
-//      This means that we don't cache Handle information within the (En|De)coder,
-//      except we really need it at Reset(...)
-//    - Consider adding math/big support
-//    - Consider reducing the size of the generated functions:
-//      Maybe use one loop, and put the conditionals in the loop.
-//      for ... { if cLen > 0 { if j == cLen { break } } else if dd.CheckBreak() { break } }
+//   - In Go 1.10, when mid-stack inlining is enabled,
+//     we should use committed functions for writeXXX and readXXX calls.
+//     This involves uncommenting the methods for decReaderSwitch and encWriterSwitch
+//     and using those (decReaderSwitch and encWriterSwitch in all handles
+//     instead of encWriter and decReader.
+//   - removing conditionals used to avoid calling no-op functions via interface calls.
+//     esep, etc.
+//     It *should* make the code cleaner, and maybe more performant,
+//     as conditional branches are expensive.
+//     However, per https://groups.google.com/forum/#!topic/golang-nuts/DNELyNnTzFA ,
+//     there is no optimization if calling an empty function via an interface.
diff --git a/vendor/github.com/ugorji/go/codec/README.md b/vendor/github.com/ugorji/go/codec/README.md
deleted file mode 100644
index cadc41b4c..000000000
--- a/vendor/github.com/ugorji/go/codec/README.md
+++ /dev/null
@@ -1,166 +0,0 @@
-# Codec
-
-High Performance, Feature-Rich Idiomatic Go codec/encoding library for
-binc, msgpack, cbor, json.
-
-Supported Serialization formats are:
-
-  - msgpack: https://github.com/msgpack/msgpack
-  - binc:    http://github.com/ugorji/binc
-  - cbor:    http://cbor.io http://tools.ietf.org/html/rfc7049
-  - json:    http://json.org http://tools.ietf.org/html/rfc7159
-  - simple: 
-
-To install:
-
-    go get github.com/ugorji/go/codec
-
-This package will carefully use 'unsafe' for performance reasons in specific places.
-You can build without unsafe use by passing the safe or appengine tag
-i.e. 'go install -tags=safe ...'. Note that unsafe is only supported for the last 3
-go sdk versions e.g. current go release is go 1.9, so we support unsafe use only from
-go 1.7+ . This is because supporting unsafe requires knowledge of implementation details.
-
-Online documentation: http://godoc.org/github.com/ugorji/go/codec  
-Detailed Usage/How-to Primer: http://ugorji.net/blog/go-codec-primer
-
-The idiomatic Go support is as seen in other encoding packages in
-the standard library (ie json, xml, gob, etc).
-
-Rich Feature Set includes:
-
-  - Simple but extremely powerful and feature-rich API
-  - Support for go1.4 and above, while selectively using newer APIs for later releases
-  - Good code coverage ( > 70% )
-  - Very High Performance.
-    Our extensive benchmarks show us outperforming Gob, Json, Bson, etc by 2-4X.
-  - Careful selected use of 'unsafe' for targeted performance gains.
-    100% mode exists where 'unsafe' is not used at all.
-  - Lock-free (sans mutex) concurrency for scaling to 100's of cores
-  - Multiple conversions:
-    Package coerces types where appropriate 
-    e.g. decode an int in the stream into a float, etc.
-  - Corner Cases: 
-    Overflows, nil maps/slices, nil values in streams are handled correctly
-  - Standard field renaming via tags
-  - Support for omitting empty fields during an encoding
-  - Encoding from any value and decoding into pointer to any value
-    (struct, slice, map, primitives, pointers, interface{}, etc)
-  - Extensions to support efficient encoding/decoding of any named types
-  - Support encoding.(Binary|Text)(M|Unm)arshaler interfaces
-  - Decoding without a schema (into a interface{}).
-    Includes Options to configure what specific map or slice type to use
-    when decoding an encoded list or map into a nil interface{}
-  - Encode a struct as an array, and decode struct from an array in the data stream
-  - Comprehensive support for anonymous fields
-  - Fast (no-reflection) encoding/decoding of common maps and slices
-  - Code-generation for faster performance.
-  - Support binary (e.g. messagepack, cbor) and text (e.g. json) formats
-  - Support indefinite-length formats to enable true streaming 
-    (for formats which support it e.g. json, cbor)
-  - Support canonical encoding, where a value is ALWAYS encoded as same sequence of bytes.
-    This mostly applies to maps, where iteration order is non-deterministic.
-  - NIL in data stream decoded as zero value
-  - Never silently skip data when decoding.
-    User decides whether to return an error or silently skip data when keys or indexes
-    in the data stream do not map to fields in the struct.
-  - Encode/Decode from/to chan types (for iterative streaming support)
-  - Drop-in replacement for encoding/json. `json:` key in struct tag supported.
-  - Provides a RPC Server and Client Codec for net/rpc communication protocol.
-  - Handle unique idiosyncrasies of codecs e.g. 
-    - For messagepack, configure how ambiguities in handling raw bytes are resolved 
-    - For messagepack, provide rpc server/client codec to support
-      msgpack-rpc protocol defined at:
-      https://github.com/msgpack-rpc/msgpack-rpc/blob/master/spec.md
-
-## Extension Support
-
-Users can register a function to handle the encoding or decoding of
-their custom types.
-
-There are no restrictions on what the custom type can be. Some examples:
-
-    type BisSet   []int
-    type BitSet64 uint64
-    type UUID     string
-    type MyStructWithUnexportedFields struct { a int; b bool; c []int; }
-    type GifImage struct { ... }
-
-As an illustration, MyStructWithUnexportedFields would normally be
-encoded as an empty map because it has no exported fields, while UUID
-would be encoded as a string. However, with extension support, you can
-encode any of these however you like.
-
-## RPC
-
-RPC Client and Server Codecs are implemented, so the codecs can be used
-with the standard net/rpc package.
-
-## Usage
-
-Typical usage model:
-
-    // create and configure Handle
-    var (
-      bh codec.BincHandle
-      mh codec.MsgpackHandle
-      ch codec.CborHandle
-    )
-
-    mh.MapType = reflect.TypeOf(map[string]interface{}(nil))
-
-    // configure extensions
-    // e.g. for msgpack, define functions and enable Time support for tag 1
-    // mh.SetExt(reflect.TypeOf(time.Time{}), 1, myExt)
-
-    // create and use decoder/encoder
-    var (
-      r io.Reader
-      w io.Writer
-      b []byte
-      h = &bh // or mh to use msgpack
-    )
-
-    dec = codec.NewDecoder(r, h)
-    dec = codec.NewDecoderBytes(b, h)
-    err = dec.Decode(&v)
-
-    enc = codec.NewEncoder(w, h)
-    enc = codec.NewEncoderBytes(&b, h)
-    err = enc.Encode(v)
-
-    //RPC Server
-    go func() {
-        for {
-            conn, err := listener.Accept()
-            rpcCodec := codec.GoRpc.ServerCodec(conn, h)
-            //OR rpcCodec := codec.MsgpackSpecRpc.ServerCodec(conn, h)
-            rpc.ServeCodec(rpcCodec)
-        }
-    }()
-
-    //RPC Communication (client side)
-    conn, err = net.Dial("tcp", "localhost:5555")
-    rpcCodec := codec.GoRpc.ClientCodec(conn, h)
-    //OR rpcCodec := codec.MsgpackSpecRpc.ClientCodec(conn, h)
-    client := rpc.NewClientWithCodec(rpcCodec)
-
-## Running Tests
-
-To run tests, use the following:
-
-    go test
-
-To run the full suite of tests, use the following:
-
-    go test -tags alltests -run Suite
-
-You can run the tag 'safe' to run tests or build in safe mode. e.g.
-
-    go test -tags safe -run Json
-    go test -tags "alltests safe" -run Suite
-
-## Running Benchmarks
-
-Please see http://github.com/ugorji/go-codec-bench .
-
diff --git a/vendor/github.com/ugorji/go/codec/binc.go b/vendor/github.com/ugorji/go/codec/binc.go
index a5b114345..98863d2d3 100644
--- a/vendor/github.com/ugorji/go/codec/binc.go
+++ b/vendor/github.com/ugorji/go/codec/binc.go
@@ -61,33 +61,37 @@ type bincEncDriver struct {
 	m map[string]uint16 // symbols
 	b [scratchByteArrayLen]byte
 	s uint16 // symbols sequencer
-	encNoSeparator
+	// encNoSeparator
+	encDriverNoopContainerWriter
+	noBuiltInTypes
 }
 
-func (e *bincEncDriver) IsBuiltinType(rt uintptr) bool {
-	return rt == timeTypId
-}
-
-func (e *bincEncDriver) EncodeBuiltin(rt uintptr, v interface{}) {
-	if rt == timeTypId {
-		var bs []byte
-		switch x := v.(type) {
-		case time.Time:
-			bs = encodeTime(x)
-		case *time.Time:
-			bs = encodeTime(*x)
-		default:
-			e.e.errorf("binc error encoding builtin: expect time.Time, received %T", v)
-		}
-		e.w.writen1(bincVdTimestamp<<4 | uint8(len(bs)))
-		e.w.writeb(bs)
-	}
-}
+// func (e *bincEncDriver) IsBuiltinType(rt uintptr) bool {
+// 	return rt == timeTypId
+// }
 
 func (e *bincEncDriver) EncodeNil() {
 	e.w.writen1(bincVdSpecial<<4 | bincSpNil)
 }
 
+// func (e *bincEncDriver) EncodeBuiltin(rt uintptr, v interface{}) {
+// 	if rt == timeTypId {
+// 		e.EncodeTime(v.(time.Time))
+// 		return
+// 	}
+// 	e.e.errorf("binc error encoding builtin: expect time.Time, received %T", v)
+// }
+
+func (e *bincEncDriver) EncodeTime(t time.Time) {
+	if t.IsZero() {
+		e.EncodeNil()
+	} else {
+		bs := encodeTime(t)
+		e.w.writen1(bincVdTimestamp<<4 | uint8(len(bs)))
+		e.w.writeb(bs)
+	}
+}
+
 func (e *bincEncDriver) EncodeBool(b bool) {
 	if b {
 		e.w.writen1(bincVdSpecial<<4 | bincSpTrue)
@@ -195,11 +199,11 @@ func (e *bincEncDriver) encodeExtPreamble(xtag byte, length int) {
 	e.w.writen1(xtag)
 }
 
-func (e *bincEncDriver) EncodeArrayStart(length int) {
+func (e *bincEncDriver) WriteArrayStart(length int) {
 	e.encLen(bincVdArray<<4, uint64(length))
 }
 
-func (e *bincEncDriver) EncodeMapStart(length int) {
+func (e *bincEncDriver) WriteMapStart(length int) {
 	e.encLen(bincVdMap<<4, uint64(length))
 }
 
@@ -213,7 +217,7 @@ func (e *bincEncDriver) EncodeString(c charEncoding, v string) {
 
 func (e *bincEncDriver) EncodeSymbol(v string) {
 	// if WriteSymbolsNoRefs {
-	// 	e.encodeString(c_UTF8, v)
+	// 	e.encodeString(cUTF8, v)
 	// 	return
 	// }
 
@@ -223,10 +227,10 @@ func (e *bincEncDriver) EncodeSymbol(v string) {
 
 	l := len(v)
 	if l == 0 {
-		e.encBytesLen(c_UTF8, 0)
+		e.encBytesLen(cUTF8, 0)
 		return
 	} else if l == 1 {
-		e.encBytesLen(c_UTF8, 1)
+		e.encBytesLen(cUTF8, 1)
 		e.w.writen1(v[0])
 		return
 	}
@@ -276,6 +280,10 @@ func (e *bincEncDriver) EncodeSymbol(v string) {
 }
 
 func (e *bincEncDriver) EncodeStringBytes(c charEncoding, v []byte) {
+	if v == nil {
+		e.EncodeNil()
+		return
+	}
 	l := uint64(len(v))
 	e.encBytesLen(c, l)
 	if l > 0 {
@@ -285,7 +293,7 @@ func (e *bincEncDriver) EncodeStringBytes(c charEncoding, v []byte) {
 
 func (e *bincEncDriver) encBytesLen(c charEncoding, length uint64) {
 	//TODO: support bincUnicodeOther (for now, just use string or bytearray)
-	if c == c_RAW {
+	if c == cRAW {
 		e.encLen(bincVdByteArray<<4, length)
 	} else {
 		e.encLen(bincVdString<<4, length)
@@ -332,13 +340,15 @@ type bincDecDriver struct {
 	bd     byte
 	vd     byte
 	vs     byte
-	noStreamingCodec
-	decNoSeparator
+	// noStreamingCodec
+	// decNoSeparator
 	b [scratchByteArrayLen]byte
 
 	// linear searching on this slice is ok,
 	// because we typically expect < 32 symbols in each stream.
 	s []bincDecSymbol
+	decDriverNoopContainerReader
+	noBuiltInTypes
 }
 
 func (d *bincDecDriver) readNextBd() {
@@ -369,9 +379,10 @@ func (d *bincDecDriver) ContainerType() (vt valueType) {
 		return valueTypeArray
 	} else if d.vd == bincVdMap {
 		return valueTypeMap
-	} else {
-		// d.d.errorf("isContainerType: unsupported parameter: %v", vt)
 	}
+	// else {
+	// d.d.errorf("isContainerType: unsupported parameter: %v", vt)
+	// }
 	return valueTypeUnset
 }
 
@@ -386,29 +397,39 @@ func (d *bincDecDriver) TryDecodeAsNil() bool {
 	return false
 }
 
-func (d *bincDecDriver) IsBuiltinType(rt uintptr) bool {
-	return rt == timeTypId
-}
+// func (d *bincDecDriver) IsBuiltinType(rt uintptr) bool {
+// 	return rt == timeTypId
+// }
 
-func (d *bincDecDriver) DecodeBuiltin(rt uintptr, v interface{}) {
+func (d *bincDecDriver) DecodeTime() (t time.Time) {
 	if !d.bdRead {
 		d.readNextBd()
 	}
-	if rt == timeTypId {
-		if d.vd != bincVdTimestamp {
-			d.d.errorf("Invalid d.vd. Expecting 0x%x. Received: 0x%x", bincVdTimestamp, d.vd)
-			return
-		}
-		tt, err := decodeTime(d.r.readx(int(d.vs)))
-		if err != nil {
-			panic(err)
-		}
-		var vt *time.Time = v.(*time.Time)
-		*vt = tt
+	if d.bd == bincVdSpecial<<4|bincSpNil {
 		d.bdRead = false
+		return
 	}
+	if d.vd != bincVdTimestamp {
+		d.d.errorf("Invalid d.vd. Expecting 0x%x. Received: 0x%x", bincVdTimestamp, d.vd)
+		return
+	}
+	t, err := decodeTime(d.r.readx(int(d.vs)))
+	if err != nil {
+		panic(err)
+	}
+	d.bdRead = false
+	return
 }
 
+// func (d *bincDecDriver) DecodeBuiltin(rt uintptr, v interface{}) {
+// 	if rt == timeTypId {
+// 		var vt = v.(*time.Time)
+// 		*vt = d.DecodeTime()
+// 		return
+// 	}
+// 	d.d.errorf("binc error decoding builtin: expect *time.Time, received %T", v)
+// }
+
 func (d *bincDecDriver) decFloatPre(vs, defaultLen byte) {
 	if vs&0x8 == 0 {
 		d.r.readb(d.b[0:defaultLen])
@@ -512,7 +533,7 @@ func (d *bincDecDriver) DecodeInt(bitsize uint8) (i int64) {
 		i = -i
 	}
 	if chkOvf.Int(i, bitsize) {
-		d.d.errorf("binc: overflow integer: %v", i)
+		d.d.errorf("binc: overflow integer: %v for num bits: %v", i, bitsize)
 		return
 	}
 	d.bdRead = false
@@ -533,7 +554,7 @@ func (d *bincDecDriver) DecodeUint(bitsize uint8) (ui uint64) {
 	return
 }
 
-func (d *bincDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) {
+func (d *bincDecDriver) DecodeFloat64() (f float64) {
 	if !d.bdRead {
 		d.readNextBd()
 	}
@@ -557,10 +578,6 @@ func (d *bincDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) {
 	} else {
 		f = float64(d.DecodeInt(64))
 	}
-	if chkOverflow32 && chkOvf.Float32(f) {
-		d.d.errorf("binc: float32 overflow: %v", f)
-		return
-	}
 	d.bdRead = false
 	return
 }
@@ -639,7 +656,7 @@ func (d *bincDecDriver) decStringAndBytes(bs []byte, withString, zerocopy bool)
 		d.bdRead = false
 		return
 	}
-	var slen int = -1
+	var slen = -1
 	// var ok bool
 	switch d.vd {
 	case bincVdString, bincVdByteArray:
@@ -741,6 +758,11 @@ func (d *bincDecDriver) DecodeBytes(bs []byte, zerocopy bool) (bsOut []byte) {
 		d.bdRead = false
 		return nil
 	}
+	// check if an "array" of uint8's (see ContainerType for how to infer if an array)
+	if d.vd == bincVdArray {
+		bsOut, _ = fastpathTV.DecSliceUint8V(bs, true, d.d)
+		return
+	}
 	var clen int
 	if d.vd == bincVdString || d.vd == bincVdByteArray {
 		clen = d.decLen()
@@ -804,7 +826,7 @@ func (d *bincDecDriver) DecodeNaked() {
 		d.readNextBd()
 	}
 
-	n := &d.d.n
+	n := d.d.n
 	var decodeFurther bool
 
 	switch d.vd {
@@ -861,7 +883,7 @@ func (d *bincDecDriver) DecodeNaked() {
 		n.v = valueTypeBytes
 		n.l = d.DecodeBytes(nil, false)
 	case bincVdTimestamp:
-		n.v = valueTypeTimestamp
+		n.v = valueTypeTime
 		tt, err := decodeTime(d.r.readx(int(d.vs)))
 		if err != nil {
 			panic(err)
@@ -909,8 +931,13 @@ func (d *bincDecDriver) DecodeNaked() {
 type BincHandle struct {
 	BasicHandle
 	binaryEncodingType
+	noElemSeparators
 }
 
+// Name returns the name of the handle: binc
+func (h *BincHandle) Name() string { return "binc" }
+
+// SetBytesExt sets an extension
 func (h *BincHandle) SetBytesExt(rt reflect.Type, tag uint64, ext BytesExt) (err error) {
 	return h.SetExt(rt, tag, &setExtWrapper{b: ext})
 }
@@ -923,6 +950,12 @@ func (h *BincHandle) newDecDriver(d *Decoder) decDriver {
 	return &bincDecDriver{d: d, h: h, r: d.r, br: d.bytes}
 }
 
+// // IsBuiltinType returns true for time.Time, else false.
+// // only time.Time is builtin.
+// func (h *BincHandle) IsBuiltinType(rt uintptr) bool {
+// 	return rt == timeTypId
+// }
+
 func (e *bincEncDriver) reset() {
 	e.w = e.e.w
 	e.s = 0
diff --git a/vendor/github.com/ugorji/go/codec/cbor.go b/vendor/github.com/ugorji/go/codec/cbor.go
index 054dbd2f1..e5c0df3a1 100644
--- a/vendor/github.com/ugorji/go/codec/cbor.go
+++ b/vendor/github.com/ugorji/go/codec/cbor.go
@@ -6,6 +6,7 @@ package codec
 import (
 	"math"
 	"reflect"
+	"time"
 )
 
 const (
@@ -38,6 +39,8 @@ const (
 	cborBdBreak                 = 0xff
 )
 
+// These define some in-stream descriptors for
+// manual encoding e.g. when doing explicit indefinite-length
 const (
 	CborStreamBytes  byte = 0x5f
 	CborStreamString      = 0x7f
@@ -61,7 +64,8 @@ const (
 
 type cborEncDriver struct {
 	noBuiltInTypes
-	encNoSeparator
+	encDriverNoopContainerWriter
+	// encNoSeparator
 	e *Encoder
 	w encWriter
 	h *CborHandle
@@ -123,6 +127,24 @@ func (e *cborEncDriver) encLen(bd byte, length int) {
 	e.encUint(uint64(length), bd)
 }
 
+func (e *cborEncDriver) EncodeTime(t time.Time) {
+	if t.IsZero() {
+		e.EncodeNil()
+	} else if e.h.TimeRFC3339 {
+		e.encUint(0, cborBaseTag)
+		e.EncodeString(cUTF8, t.Format(time.RFC3339Nano))
+	} else {
+		e.encUint(1, cborBaseTag)
+		t = t.UTC().Round(time.Microsecond)
+		sec, nsec := t.Unix(), uint64(t.Nanosecond())
+		if nsec == 0 {
+			e.EncodeInt(sec)
+		} else {
+			e.EncodeFloat64(float64(sec) + float64(nsec)/1e9)
+		}
+	}
+}
+
 func (e *cborEncDriver) EncodeExt(rv interface{}, xtag uint64, ext Ext, en *Encoder) {
 	e.encUint(uint64(xtag), cborBaseTag)
 	if v := ext.ConvertExt(rv); v == nil {
@@ -134,39 +156,91 @@ func (e *cborEncDriver) EncodeExt(rv interface{}, xtag uint64, ext Ext, en *Enco
 
 func (e *cborEncDriver) EncodeRawExt(re *RawExt, en *Encoder) {
 	e.encUint(uint64(re.Tag), cborBaseTag)
-	if re.Data != nil {
+	if false && re.Data != nil {
 		en.encode(re.Data)
-	} else if re.Value == nil {
-		e.EncodeNil()
-	} else {
+	} else if re.Value != nil {
 		en.encode(re.Value)
+	} else {
+		e.EncodeNil()
 	}
 }
 
-func (e *cborEncDriver) EncodeArrayStart(length int) {
-	e.encLen(cborBaseArray, length)
+func (e *cborEncDriver) WriteArrayStart(length int) {
+	if e.h.IndefiniteLength {
+		e.w.writen1(cborBdIndefiniteArray)
+	} else {
+		e.encLen(cborBaseArray, length)
+	}
 }
 
-func (e *cborEncDriver) EncodeMapStart(length int) {
-	e.encLen(cborBaseMap, length)
+func (e *cborEncDriver) WriteMapStart(length int) {
+	if e.h.IndefiniteLength {
+		e.w.writen1(cborBdIndefiniteMap)
+	} else {
+		e.encLen(cborBaseMap, length)
+	}
 }
 
-func (e *cborEncDriver) EncodeString(c charEncoding, v string) {
-	e.encLen(cborBaseString, len(v))
-	e.w.writestr(v)
+func (e *cborEncDriver) WriteMapEnd() {
+	if e.h.IndefiniteLength {
+		e.w.writen1(cborBdBreak)
+	}
+}
+
+func (e *cborEncDriver) WriteArrayEnd() {
+	if e.h.IndefiniteLength {
+		e.w.writen1(cborBdBreak)
+	}
 }
 
 func (e *cborEncDriver) EncodeSymbol(v string) {
-	e.EncodeString(c_UTF8, v)
+	e.encStringBytesS(cborBaseString, v)
+}
+
+func (e *cborEncDriver) EncodeString(c charEncoding, v string) {
+	e.encStringBytesS(cborBaseString, v)
 }
 
 func (e *cborEncDriver) EncodeStringBytes(c charEncoding, v []byte) {
-	if c == c_RAW {
-		e.encLen(cborBaseBytes, len(v))
+	if v == nil {
+		e.EncodeNil()
+	} else if c == cRAW {
+		e.encStringBytesS(cborBaseBytes, stringView(v))
 	} else {
-		e.encLen(cborBaseString, len(v))
+		e.encStringBytesS(cborBaseString, stringView(v))
+	}
+}
+
+func (e *cborEncDriver) encStringBytesS(bb byte, v string) {
+	if e.h.IndefiniteLength {
+		if bb == cborBaseBytes {
+			e.w.writen1(cborBdIndefiniteBytes)
+		} else {
+			e.w.writen1(cborBdIndefiniteString)
+		}
+		blen := len(v) / 4
+		if blen == 0 {
+			blen = 64
+		} else if blen > 1024 {
+			blen = 1024
+		}
+		for i := 0; i < len(v); {
+			var v2 string
+			i2 := i + blen
+			if i2 < len(v) {
+				v2 = v[i:i2]
+			} else {
+				v2 = v[i:]
+			}
+			e.encLen(bb, len(v2))
+			e.w.writestr(v2)
+			i = i2
+		}
+		e.w.writen1(cborBdBreak)
+	} else {
+		e.encLen(bb, len(v))
+		e.w.writestr(v)
 	}
-	e.w.writeb(v)
 }
 
 // ----------------------
@@ -180,7 +254,8 @@ type cborDecDriver struct {
 	bdRead bool
 	bd     byte
 	noBuiltInTypes
-	decNoSeparator
+	// decNoSeparator
+	decDriverNoopContainerReader
 }
 
 func (d *cborDecDriver) readNextBd() {
@@ -209,9 +284,10 @@ func (d *cborDecDriver) ContainerType() (vt valueType) {
 		return valueTypeArray
 	} else if d.bd == cborBdIndefiniteMap || (d.bd >= cborBaseMap && d.bd < cborBaseTag) {
 		return valueTypeMap
-	} else {
-		// d.d.errorf("isContainerType: unsupported parameter: %v", vt)
 	}
+	// else {
+	// d.d.errorf("isContainerType: unsupported parameter: %v", vt)
+	// }
 	return valueTypeUnset
 }
 
@@ -313,7 +389,7 @@ func (d *cborDecDriver) DecodeUint(bitsize uint8) (ui uint64) {
 	return
 }
 
-func (d *cborDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) {
+func (d *cborDecDriver) DecodeFloat64() (f float64) {
 	if !d.bdRead {
 		d.readNextBd()
 	}
@@ -329,10 +405,6 @@ func (d *cborDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) {
 		d.d.errorf("Float only valid from float16/32/64: Invalid descriptor: %v", bd)
 		return
 	}
-	if chkOverflow32 && chkOvf.Float32(f) {
-		d.d.errorf("cbor: float32 overflow: %v", f)
-		return
-	}
 	d.bdRead = false
 	return
 }
@@ -416,11 +488,17 @@ func (d *cborDecDriver) DecodeBytes(bs []byte, zerocopy bool) (bsOut []byte) {
 		return nil
 	}
 	if d.bd == cborBdIndefiniteBytes || d.bd == cborBdIndefiniteString {
+		d.bdRead = false
 		if bs == nil {
-			return d.decAppendIndefiniteBytes(nil)
+			return d.decAppendIndefiniteBytes(zeroByteSlice)
 		}
 		return d.decAppendIndefiniteBytes(bs[:0])
 	}
+	// check if an "array" of uint8's (see ContainerType for how to infer if an array)
+	if d.bd == cborBdIndefiniteArray || (d.bd >= cborBaseArray && d.bd < cborBaseMap) {
+		bsOut, _ = fastpathTV.DecSliceUint8V(bs, true, d.d)
+		return
+	}
 	clen := d.decLen()
 	d.bdRead = false
 	if zerocopy {
@@ -441,6 +519,51 @@ func (d *cborDecDriver) DecodeStringAsBytes() (s []byte) {
 	return d.DecodeBytes(d.b[:], true)
 }
 
+func (d *cborDecDriver) DecodeTime() (t time.Time) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
+	if d.bd == cborBdNil || d.bd == cborBdUndefined {
+		d.bdRead = false
+		return
+	}
+	xtag := d.decUint()
+	d.bdRead = false
+	return d.decodeTime(xtag)
+}
+
+func (d *cborDecDriver) decodeTime(xtag uint64) (t time.Time) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
+	switch xtag {
+	case 0:
+		var err error
+		if t, err = time.Parse(time.RFC3339, stringView(d.DecodeStringAsBytes())); err != nil {
+			d.d.errorv(err)
+		}
+	case 1:
+		// decode an int64 or a float, and infer time.Time from there.
+		// for floats, round to microseconds, as that is what is guaranteed to fit well.
+		switch {
+		case d.bd == cborBdFloat16, d.bd == cborBdFloat32:
+			f1, f2 := math.Modf(d.DecodeFloat64())
+			t = time.Unix(int64(f1), int64(f2*1e9))
+		case d.bd == cborBdFloat64:
+			f1, f2 := math.Modf(d.DecodeFloat64())
+			t = time.Unix(int64(f1), int64(f2*1e9))
+		case d.bd >= cborBaseUint && d.bd < cborBaseNegInt, d.bd >= cborBaseNegInt && d.bd < cborBaseBytes:
+			t = time.Unix(d.DecodeInt(64), 0)
+		default:
+			d.d.errorf("cbor: time.Time can only be decoded from a number (or RFC3339 string)")
+		}
+	default:
+		d.d.errorf("cbor: invalid tag for time.Time - expecting 0 or 1, got 0x%x", xtag)
+	}
+	t = t.UTC().Round(time.Microsecond)
+	return
+}
+
 func (d *cborDecDriver) DecodeExt(rv interface{}, xtag uint64, ext Ext) (realxtag uint64) {
 	if !d.bdRead {
 		d.readNextBd()
@@ -469,7 +592,7 @@ func (d *cborDecDriver) DecodeNaked() {
 		d.readNextBd()
 	}
 
-	n := &d.d.n
+	n := d.d.n
 	var decodeFurther bool
 
 	switch d.bd {
@@ -481,12 +604,9 @@ func (d *cborDecDriver) DecodeNaked() {
 	case cborBdTrue:
 		n.v = valueTypeBool
 		n.b = true
-	case cborBdFloat16, cborBdFloat32:
+	case cborBdFloat16, cborBdFloat32, cborBdFloat64:
 		n.v = valueTypeFloat
-		n.f = d.DecodeFloat(true)
-	case cborBdFloat64:
-		n.v = valueTypeFloat
-		n.f = d.DecodeFloat(false)
+		n.f = d.DecodeFloat64()
 	case cborBdIndefiniteBytes:
 		n.v = valueTypeBytes
 		n.l = d.DecodeBytes(nil, false)
@@ -528,6 +648,11 @@ func (d *cborDecDriver) DecodeNaked() {
 			n.v = valueTypeExt
 			n.u = d.decUint()
 			n.l = nil
+			if n.u == 0 || n.u == 1 {
+				d.bdRead = false
+				n.v = valueTypeTime
+				n.t = d.decodeTime(n.u)
+			}
 			// d.bdRead = false
 			// d.d.decode(&re.Value) // handled by decode itself.
 			// decodeFurther = true
@@ -558,28 +683,25 @@ func (d *cborDecDriver) DecodeNaked() {
 //
 // None of the optional extensions (with tags) defined in the spec are supported out-of-the-box.
 // Users can implement them as needed (using SetExt), including spec-documented ones:
-//   - timestamp, BigNum, BigFloat, Decimals, Encoded Text (e.g. URL, regexp, base64, MIME Message), etc.
-//
-// To encode with indefinite lengths (streaming), users will use
-// (Must)Encode methods of *Encoder, along with writing CborStreamXXX constants.
-//
-// For example, to encode "one-byte" as an indefinite length string:
-//     var buf bytes.Buffer
-//     e := NewEncoder(&buf, new(CborHandle))
-//     buf.WriteByte(CborStreamString)
-//     e.MustEncode("one-")
-//     e.MustEncode("byte")
-//     buf.WriteByte(CborStreamBreak)
-//     encodedBytes := buf.Bytes()
-//     var vv interface{}
-//     NewDecoderBytes(buf.Bytes(), new(CborHandle)).MustDecode(&vv)
-//     // Now, vv contains the same string "one-byte"
-//
+//   - timestamp, BigNum, BigFloat, Decimals,
+//   - Encoded Text (e.g. URL, regexp, base64, MIME Message), etc.
 type CborHandle struct {
 	binaryEncodingType
+	noElemSeparators
 	BasicHandle
+
+	// IndefiniteLength=true, means that we encode using indefinitelength
+	IndefiniteLength bool
+
+	// TimeRFC3339 says to encode time.Time using RFC3339 format.
+	// If unset, we encode time.Time using seconds past epoch.
+	TimeRFC3339 bool
 }
 
+// Name returns the name of the handle: cbor
+func (h *CborHandle) Name() string { return "cbor" }
+
+// SetInterfaceExt sets an extension
 func (h *CborHandle) SetInterfaceExt(rt reflect.Type, tag uint64, ext InterfaceExt) (err error) {
 	return h.SetExt(rt, tag, &setExtWrapper{i: ext})
 }
diff --git a/vendor/github.com/ugorji/go/codec/cbor_test.go b/vendor/github.com/ugorji/go/codec/cbor_test.go
index 205dffa7d..af9402710 100644
--- a/vendor/github.com/ugorji/go/codec/cbor_test.go
+++ b/vendor/github.com/ugorji/go/codec/cbor_test.go
@@ -97,7 +97,7 @@ type testCborGolden struct {
 }
 
 // Some tests are skipped because they include numbers outside the range of int64/uint64
-func doTestCborGoldens(t *testing.T) {
+func TestCborGoldens(t *testing.T) {
 	oldMapType := testCborH.MapType
 	defer func() {
 		testCborH.MapType = oldMapType
@@ -200,6 +200,31 @@ func testCborError(t *testing.T, i int, v0, v1 interface{}, err error, equal *bo
 	// fmt.Printf("%v testCborError passed (checks passed)\n", i)
 }
 
-func TestCborGoldens(t *testing.T) {
-	doTestCborGoldens(t)
+func TestCborHalfFloat(t *testing.T) {
+	m := map[uint16]float64{
+		// using examples from
+		// https://en.wikipedia.org/wiki/Half-precision_floating-point_format
+		0x3c00: 1,
+		0x3c01: 1 + math.Pow(2, -10),
+		0xc000: -2,
+		0x7bff: 65504,
+		0x0400: math.Pow(2, -14),
+		0x03ff: math.Pow(2, -14) - math.Pow(2, -24),
+		0x0001: math.Pow(2, -24),
+		0x0000: 0,
+		0x8000: -0.0,
+	}
+	var ba [3]byte
+	ba[0] = cborBdFloat16
+	var res float64
+	for k, v := range m {
+		res = 0
+		bigen.PutUint16(ba[1:], k)
+		testUnmarshalErr(&res, ba[:3], testCborH, t, "-")
+		if res == v {
+			logT(t, "equal floats: from %x %b, %v", k, k, v)
+		} else {
+			failT(t, "unequal floats: from %x %b, %v != %v", k, k, res, v)
+		}
+	}
 }
diff --git a/vendor/github.com/ugorji/go/codec/codec_test.go b/vendor/github.com/ugorji/go/codec/codec_test.go
index eb8830ba1..40476e67f 100644
--- a/vendor/github.com/ugorji/go/codec/codec_test.go
+++ b/vendor/github.com/ugorji/go/codec/codec_test.go
@@ -3,26 +3,12 @@
 
 package codec
 
-// Test works by using a slice of interfaces.
-// It can test for encoding/decoding into/from a nil interface{}
-// or passing the object to encode/decode into.
-//
-// There are basically 2 main tests here.
-// First test internally encodes and decodes things and verifies that
-// the artifact was as expected.
-// Second test will use python msgpack to create a bunch of golden files,
-// read those files, and compare them to what it should be. It then
-// writes those files back out and compares the byte streams.
-//
-// Taken together, the tests are pretty extensive.
-//
-// The following manual tests must be done:
-//   - TestCodecUnderlyingType
-
 import (
+	"bufio"
 	"bytes"
 	"encoding/gob"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"math"
 	"math/rand"
@@ -42,29 +28,50 @@ import (
 
 func init() {
 	testPreInitFns = append(testPreInitFns, testInit)
+	// fmt.Printf("sizeof: Decoder: %v, Encoder: %v, decNaked: %v\n",
+	// 	reflect.TypeOf((*Decoder)(nil)).Elem().Size(),
+	// 	reflect.TypeOf((*Encoder)(nil)).Elem().Size(),
+	// 	reflect.TypeOf((*decNaked)(nil)).Elem().Size(),
+	// )
 }
 
+type testCustomStringT string
+
 // make this a mapbyslice
 type testMbsT []interface{}
 
-func (_ testMbsT) MapBySlice() {}
+func (testMbsT) MapBySlice() {}
 
-type testVerifyArg int
+type testMbsCustStrT []testCustomStringT
+
+func (testMbsCustStrT) MapBySlice() {}
+
+type testVerifyFlag uint8
 
 const (
-	testVerifyMapTypeSame testVerifyArg = iota
+	_ testVerifyFlag = 1 << iota
+	testVerifyMapTypeSame
 	testVerifyMapTypeStrIntf
 	testVerifyMapTypeIntfIntf
 	// testVerifySliceIntf
 	testVerifyForPython
+	testVerifyDoNil
+	testVerifyTimeAsInteger
 )
 
-const testSkipRPCTests = false
+func (f testVerifyFlag) isset(v testVerifyFlag) bool {
+	return f&v == v
+}
+
+// const testSkipRPCTests = false
 
 var (
 	testTableNumPrimitives int
 	testTableIdxTime       int
 	testTableNumMaps       int
+
+	// set this when running using bufio, etc
+	testSkipRPCTests = false
 )
 
 var (
@@ -82,14 +89,14 @@ var (
 	//timeToCompare4 = time.Time{}.UTC() // does not work well with simple cbor time encoding (overflow)
 	timeToCompare4 = time.Unix(-2013855848, 4223).UTC()
 
-	table              []interface{} // main items we encode
-	tableVerify        []interface{} // we verify encoded things against this after decode
-	tableTestNilVerify []interface{} // for nil interface, use this to verify (rules are different)
-	tablePythonVerify  []interface{} // for verifying for python, since Python sometimes
+	table []interface{} // main items we encode
 	// will encode a float32 as float64, or large int as uint
 	testRpcInt = new(TestRpcInt)
 )
 
+var wrapInt64Typ = reflect.TypeOf(wrapInt64(0))
+var wrapBytesTyp = reflect.TypeOf(wrapBytes(nil))
+
 func testByteBuf(in []byte) *bytes.Buffer {
 	return bytes.NewBuffer(in)
 }
@@ -167,215 +174,243 @@ type TestRawValue struct {
 	I int
 }
 
+// ----
+
 type testUnixNanoTimeExt struct {
 	// keep timestamp here, so that do not incur interface-conversion costs
-	ts int64
+	// ts int64
 }
 
-// func (x *testUnixNanoTimeExt) WriteExt(interface{}) []byte { panic("unsupported") }
-// func (x *testUnixNanoTimeExt) ReadExt(interface{}, []byte) { panic("unsupported") }
-func (x *testUnixNanoTimeExt) ConvertExt(v interface{}) interface{} {
-	switch v2 := v.(type) {
-	case time.Time:
-		x.ts = v2.UTC().UnixNano()
-	case *time.Time:
-		x.ts = v2.UTC().UnixNano()
-	default:
-		panic(fmt.Sprintf("unsupported format for time conversion: expecting time.Time; got %T", v))
-	}
-	return &x.ts
+func (x *testUnixNanoTimeExt) WriteExt(v interface{}) []byte {
+	v2 := v.(*time.Time)
+	bs := make([]byte, 8)
+	bigen.PutUint64(bs, uint64(v2.UnixNano()))
+	return bs
 }
+func (x *testUnixNanoTimeExt) ReadExt(v interface{}, bs []byte) {
+	v2 := v.(*time.Time)
+	ui := bigen.Uint64(bs)
+	*v2 = time.Unix(0, int64(ui)).UTC()
+}
+func (x *testUnixNanoTimeExt) ConvertExt(v interface{}) interface{} {
+	v2 := v.(*time.Time) // structs are encoded by passing the value
+	return v2.UTC().UnixNano()
+	// return x.ts
+	// switch v2 := v.(type) {
+	// case time.Time:
+	// 	x.ts = v2.UTC().UnixNano()
+	// case *time.Time:
+	// 	x.ts = v2.UTC().UnixNano()
+	// default:
+	// 	panic(fmt.Sprintf("unsupported format for time conversion: expecting time.Time; got %T", v))
+	// }
+	// return &x.ts
+}
+
 func (x *testUnixNanoTimeExt) UpdateExt(dest interface{}, v interface{}) {
-	// fmt.Printf("testUnixNanoTimeExt.UpdateExt: v: %v\n", v)
 	tt := dest.(*time.Time)
 	switch v2 := v.(type) {
 	case int64:
 		*tt = time.Unix(0, v2).UTC()
-	case *int64:
-		*tt = time.Unix(0, *v2).UTC()
 	case uint64:
 		*tt = time.Unix(0, int64(v2)).UTC()
-	case *uint64:
-		*tt = time.Unix(0, int64(*v2)).UTC()
 	//case float64:
 	//case string:
 	default:
 		panic(fmt.Sprintf("unsupported format for time conversion: expecting int64/uint64; got %T", v))
 	}
-	// fmt.Printf("testUnixNanoTimeExt.UpdateExt: v: %v, tt: %#v\n", v, tt)
 }
 
-func testVerifyVal(v interface{}, arg testVerifyArg) (v2 interface{}) {
-	//for python msgpack,
-	//  - all positive integers are unsigned 64-bit ints
-	//  - all floats are float64
-	switch iv := v.(type) {
-	case int8:
-		if iv >= 0 {
-			v2 = uint64(iv)
-		} else {
-			v2 = int64(iv)
-		}
-	case int16:
-		if iv >= 0 {
-			v2 = uint64(iv)
-		} else {
-			v2 = int64(iv)
-		}
-	case int32:
-		if iv >= 0 {
-			v2 = uint64(iv)
-		} else {
-			v2 = int64(iv)
-		}
-	case int64:
-		if iv >= 0 {
-			v2 = uint64(iv)
-		} else {
-			v2 = int64(iv)
-		}
-	case uint8:
-		v2 = uint64(iv)
-	case uint16:
-		v2 = uint64(iv)
-	case uint32:
-		v2 = uint64(iv)
-	case uint64:
-		v2 = uint64(iv)
-	case float32:
-		v2 = float64(iv)
-	case float64:
-		v2 = float64(iv)
-	case []interface{}:
-		m2 := make([]interface{}, len(iv))
-		for j, vj := range iv {
-			m2[j] = testVerifyVal(vj, arg)
-		}
-		v2 = m2
-	case testMbsT:
-		m2 := make([]interface{}, len(iv))
-		for j, vj := range iv {
-			m2[j] = testVerifyVal(vj, arg)
-		}
-		v2 = testMbsT(m2)
-	case map[string]bool:
-		switch arg {
-		case testVerifyMapTypeSame:
-			m2 := make(map[string]bool)
-			for kj, kv := range iv {
-				m2[kj] = kv
-			}
-			v2 = m2
-		case testVerifyMapTypeStrIntf, testVerifyForPython:
-			m2 := make(map[string]interface{})
-			for kj, kv := range iv {
-				m2[kj] = kv
-			}
-			v2 = m2
-		case testVerifyMapTypeIntfIntf:
-			m2 := make(map[interface{}]interface{})
-			for kj, kv := range iv {
-				m2[kj] = kv
-			}
-			v2 = m2
-		}
-	case map[string]interface{}:
-		switch arg {
-		case testVerifyMapTypeSame:
-			m2 := make(map[string]interface{})
-			for kj, kv := range iv {
-				m2[kj] = testVerifyVal(kv, arg)
-			}
-			v2 = m2
-		case testVerifyMapTypeStrIntf, testVerifyForPython:
-			m2 := make(map[string]interface{})
-			for kj, kv := range iv {
-				m2[kj] = testVerifyVal(kv, arg)
-			}
-			v2 = m2
-		case testVerifyMapTypeIntfIntf:
-			m2 := make(map[interface{}]interface{})
-			for kj, kv := range iv {
-				m2[kj] = testVerifyVal(kv, arg)
-			}
-			v2 = m2
-		}
-	case map[interface{}]interface{}:
-		m2 := make(map[interface{}]interface{})
-		for kj, kv := range iv {
-			m2[testVerifyVal(kj, arg)] = testVerifyVal(kv, arg)
-		}
-		v2 = m2
-	case time.Time:
-		switch arg {
-		case testVerifyForPython:
-			if iv2 := iv.UnixNano(); iv2 >= 0 {
-				v2 = uint64(iv2)
-			} else {
-				v2 = int64(iv2)
-			}
-		default:
-			v2 = v
-		}
+// ----
+
+type wrapInt64Ext int64
+
+func (x *wrapInt64Ext) WriteExt(v interface{}) []byte {
+	v2 := uint64(int64(v.(wrapInt64)))
+	bs := make([]byte, 8)
+	bigen.PutUint64(bs, v2)
+	return bs
+}
+func (x *wrapInt64Ext) ReadExt(v interface{}, bs []byte) {
+	v2 := v.(*wrapInt64)
+	ui := bigen.Uint64(bs)
+	*v2 = wrapInt64(int64(ui))
+}
+func (x *wrapInt64Ext) ConvertExt(v interface{}) interface{} {
+	return int64(v.(wrapInt64))
+}
+func (x *wrapInt64Ext) UpdateExt(dest interface{}, v interface{}) {
+	v2 := dest.(*wrapInt64)
+	*v2 = wrapInt64(v.(int64))
+}
+
+// ----
+
+type wrapBytesExt struct{}
+
+func (x *wrapBytesExt) WriteExt(v interface{}) []byte {
+	return ([]byte)(v.(wrapBytes))
+}
+func (x *wrapBytesExt) ReadExt(v interface{}, bs []byte) {
+	v2 := v.(*wrapBytes)
+	*v2 = wrapBytes(bs)
+}
+func (x *wrapBytesExt) ConvertExt(v interface{}) interface{} {
+	return ([]byte)(v.(wrapBytes))
+}
+func (x *wrapBytesExt) UpdateExt(dest interface{}, v interface{}) {
+	v2 := dest.(*wrapBytes)
+	// some formats (e.g. json) cannot nakedly determine []byte from string, so expect both
+	switch v3 := v.(type) {
+	case []byte:
+		*v2 = wrapBytes(v3)
+	case string:
+		*v2 = wrapBytes([]byte(v3))
 	default:
-		v2 = v
+		panic("UpdateExt for wrapBytesExt expects string or []byte")
+	}
+	// *v2 = wrapBytes(v.([]byte))
+}
+
+// ----
+
+type timeExt struct{}
+
+func (x timeExt) WriteExt(v interface{}) (bs []byte) {
+	switch v2 := v.(type) {
+	case time.Time:
+		bs = encodeTime(v2)
+	case *time.Time:
+		bs = encodeTime(*v2)
+	default:
+		panic(fmt.Errorf("unsupported format for time conversion: expecting time.Time; got %T", v2))
 	}
 	return
 }
+func (x timeExt) ReadExt(v interface{}, bs []byte) {
+	tt, err := decodeTime(bs)
+	if err != nil {
+		panic(err)
+	}
+	*(v.(*time.Time)) = tt
+}
+
+func (x timeExt) ConvertExt(v interface{}) interface{} {
+	return x.WriteExt(v)
+}
+func (x timeExt) UpdateExt(v interface{}, src interface{}) {
+	x.ReadExt(v, src.([]byte))
+}
+
+// ----
+
+func testCodecEncode(ts interface{}, bsIn []byte,
+	fn func([]byte) *bytes.Buffer, h Handle) (bs []byte, err error) {
+	return sTestCodecEncode(ts, bsIn, fn, h, h.getBasicHandle())
+}
+
+func testCodecDecode(bs []byte, ts interface{}, h Handle) (err error) {
+	return sTestCodecDecode(bs, ts, h, h.getBasicHandle())
+}
+
+func checkErrT(t *testing.T, err error) {
+	if err != nil {
+		failT(t, err.Error())
+	}
+}
+
+func checkEqualT(t *testing.T, v1 interface{}, v2 interface{}, desc string) {
+	if err := deepEqual(v1, v2); err != nil {
+		failT(t, "Not Equal: %s: %v. v1: %v, v2: %v", desc, err, v1, v2)
+	}
+}
+
+func failT(t *testing.T, args ...interface{}) {
+	if len(args) > 0 {
+		if format, isstr := args[0].(string); isstr {
+			logT(t, format, args[1:]...)
+		}
+	}
+	t.FailNow()
+}
 
 func testInit() {
-	gob.Register(new(TestStruc))
+	gob.Register(new(TestStrucFlex))
 	if testInitDebug {
-		ts0 := newTestStruc(2, false, !testSkipIntf, false)
-		fmt.Printf("====> depth: %v, ts: %#v\n", 2, ts0)
+		ts0 := newTestStrucFlex(2, testNumRepeatString, false, !testSkipIntf, false)
+		logT(nil, "====> depth: %v, ts: %#v\n", 2, ts0)
 	}
 
 	for _, v := range testHandles {
 		bh := v.getBasicHandle()
+		// pre-fill them first
+		bh.EncodeOptions = testEncodeOptions
+		bh.DecodeOptions = testDecodeOptions
+		// bh.InterfaceReset = true // TODO: remove
+		// bh.PreferArrayOverSlice = true // TODO: remove
+		// modify from flag'ish things
 		bh.InternString = testInternStr
 		bh.Canonical = testCanonical
 		bh.CheckCircularRef = testCheckCircRef
 		bh.StructToArray = testStructToArray
 		bh.MaxInitLen = testMaxInitLen
-		// mostly doing this for binc
-		if testWriteNoSymbols {
-			bh.AsSymbols = AsSymbolNone
-		} else {
-			bh.AsSymbols = AsSymbolAll
-		}
 	}
 
-	testJsonH.Indent = int8(testJsonIndent)
-	testJsonH.HTMLCharsAsIs = testJsonHTMLCharsAsIs
-	testJsonH.PreferFloat = testJsonPreferFloat
-
 	testMsgpackH.RawToString = true
 
-	// testMsgpackH.AddExt(byteSliceTyp, 0, testMsgpackH.BinaryEncodeExt, testMsgpackH.BinaryDecodeExt)
-	// testMsgpackH.AddExt(timeTyp, 1, testMsgpackH.TimeEncodeExt, testMsgpackH.TimeDecodeExt)
+	var tTimeExt timeExt
+	var tBytesExt wrapBytesExt
+	var tI64Ext wrapInt64Ext
 
-	// add extensions for msgpack, simple for time.Time, so we can encode/decode same way.
-	// use different flavors of XXXExt calls, including deprecated ones.
-	// NOTE:
-	// DO NOT set extensions for JsonH, so we can test json(M|Unm)arshal support.
+	// create legacy functions suitable for deprecated AddExt functionality,
+	// and use on some places for testSimpleH e.g. for time.Time and wrapInt64
 	var (
-		timeExtEncFn = func(rv reflect.Value) (bs []byte, err error) {
-			defer panicToErr(&err)
-			bs = timeExt{}.WriteExt(rv.Interface())
+		myExtEncFn = func(x BytesExt, rv reflect.Value) (bs []byte, err error) {
+			defer panicToErr(errstrDecoratorDef{}, &err)
+			bs = x.WriteExt(rv.Interface())
 			return
 		}
-		timeExtDecFn = func(rv reflect.Value, bs []byte) (err error) {
-			defer panicToErr(&err)
-			timeExt{}.ReadExt(rv.Interface(), bs)
+		myExtDecFn = func(x BytesExt, rv reflect.Value, bs []byte) (err error) {
+			defer panicToErr(errstrDecoratorDef{}, &err)
+			x.ReadExt(rv.Interface(), bs)
 			return
 		}
+		timeExtEncFn      = func(rv reflect.Value) (bs []byte, err error) { return myExtEncFn(tTimeExt, rv) }
+		timeExtDecFn      = func(rv reflect.Value, bs []byte) (err error) { return myExtDecFn(tTimeExt, rv, bs) }
+		wrapInt64ExtEncFn = func(rv reflect.Value) (bs []byte, err error) { return myExtEncFn(&tI64Ext, rv) }
+		wrapInt64ExtDecFn = func(rv reflect.Value, bs []byte) (err error) { return myExtDecFn(&tI64Ext, rv, bs) }
 	)
-	testSimpleH.AddExt(timeTyp, 1, timeExtEncFn, timeExtDecFn)
 
-	testMsgpackH.SetBytesExt(timeTyp, 1, timeExt{})
-	testCborH.SetInterfaceExt(timeTyp, 1, &testUnixNanoTimeExt{})
+	chkErr := func(err error) {
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	// time.Time is a native type, so extensions will have no effect.
+	// However, we add these here to ensure nothing happens.
+	chkErr(testSimpleH.AddExt(timeTyp, 1, timeExtEncFn, timeExtDecFn))
+	// testBincH.SetBytesExt(timeTyp, 1, timeExt{}) // time is builtin for binc
+	chkErr(testMsgpackH.SetBytesExt(timeTyp, 1, timeExt{}))
+	chkErr(testCborH.SetInterfaceExt(timeTyp, 1, &testUnixNanoTimeExt{}))
 	// testJsonH.SetInterfaceExt(timeTyp, 1, &testUnixNanoTimeExt{})
 
+	// Now, add extensions for the type wrapInt64 and wrapBytes,
+	// so we can execute the Encode/Decode Ext paths.
+
+	chkErr(testSimpleH.SetBytesExt(wrapBytesTyp, 32, &tBytesExt))
+	chkErr(testMsgpackH.SetBytesExt(wrapBytesTyp, 32, &tBytesExt))
+	chkErr(testBincH.SetBytesExt(wrapBytesTyp, 32, &tBytesExt))
+	chkErr(testJsonH.SetInterfaceExt(wrapBytesTyp, 32, &tBytesExt))
+	chkErr(testCborH.SetInterfaceExt(wrapBytesTyp, 32, &tBytesExt))
+
+	chkErr(testSimpleH.AddExt(wrapInt64Typ, 16, wrapInt64ExtEncFn, wrapInt64ExtDecFn))
+	// chkErr(testSimpleH.SetBytesExt(wrapInt64Typ, 16, &tI64Ext))
+	chkErr(testMsgpackH.SetBytesExt(wrapInt64Typ, 16, &tI64Ext))
+	chkErr(testBincH.SetBytesExt(wrapInt64Typ, 16, &tI64Ext))
+	chkErr(testJsonH.SetInterfaceExt(wrapInt64Typ, 16, &tI64Ext))
+	chkErr(testCborH.SetInterfaceExt(wrapInt64Typ, 16, &tI64Ext))
+
 	// primitives MUST be an even number, so it can be used as a mapBySlice also.
 	primitives := []interface{}{
 		int8(-8),
@@ -451,7 +486,7 @@ ugorji
 		map[interface{}]interface{}{
 			true:       "true",
 			uint8(138): false,
-			"false":    uint8(200),
+			false:      uint8(200),
 		},
 	}
 
@@ -464,54 +499,183 @@ ugorji
 	table = append(table, primitives)
 	table = append(table, testMbsT(primitives))
 	table = append(table, maps...)
-	table = append(table, newTestStruc(0, false, !testSkipIntf, false))
+	table = append(table, newTestStrucFlex(0, testNumRepeatString, false, !testSkipIntf, false))
 
-	tableVerify = make([]interface{}, len(table))
-	tableTestNilVerify = make([]interface{}, len(table))
-	tablePythonVerify = make([]interface{}, len(table))
+}
 
+func testTableVerify(f testVerifyFlag, h Handle) (av []interface{}) {
+	av = make([]interface{}, len(table))
 	lp := testTableNumPrimitives + 4
-	av := tableVerify
-	for i, v := range table {
-		if i == lp {
-			av[i] = skipVerifyVal
-			continue
+	// doNil := f & testVerifyDoNil == testVerifyDoNil
+	// doPython := f & testVerifyForPython == testVerifyForPython
+	switch {
+	case f.isset(testVerifyForPython):
+		for i, v := range table {
+			if i == testTableNumPrimitives+1 || i > lp { // testTableNumPrimitives+1 is the mapBySlice
+				av[i] = skipVerifyVal
+				continue
+			}
+			av[i] = testVerifyVal(v, f, h)
 		}
-		//av[i] = testVerifyVal(v, testVerifyMapTypeSame)
-		switch v.(type) {
-		case []interface{}:
-			av[i] = testVerifyVal(v, testVerifyMapTypeSame)
-		case testMbsT:
-			av[i] = testVerifyVal(v, testVerifyMapTypeSame)
-		case map[string]interface{}:
-			av[i] = testVerifyVal(v, testVerifyMapTypeSame)
-		case map[interface{}]interface{}:
-			av[i] = testVerifyVal(v, testVerifyMapTypeSame)
+		// only do the python verify up to the maps, skipping the last 2 maps.
+		av = av[:testTableNumPrimitives+2+testTableNumMaps-2]
+	case f.isset(testVerifyDoNil):
+		for i, v := range table {
+			if i > lp {
+				av[i] = skipVerifyVal
+				continue
+			}
+			av[i] = testVerifyVal(v, f, h)
+		}
+	default:
+		for i, v := range table {
+			if i == lp {
+				av[i] = skipVerifyVal
+				continue
+			}
+			//av[i] = testVerifyVal(v, testVerifyMapTypeSame)
+			switch v.(type) {
+			case []interface{}:
+				av[i] = testVerifyVal(v, f, h)
+			case testMbsT:
+				av[i] = testVerifyVal(v, f, h)
+			case map[string]interface{}:
+				av[i] = testVerifyVal(v, f, h)
+			case map[interface{}]interface{}:
+				av[i] = testVerifyVal(v, f, h)
+			case time.Time:
+				av[i] = testVerifyVal(v, f, h)
+			default:
+				av[i] = v
+			}
+		}
+	}
+	return
+}
+
+func testVerifyValInt(v int64, isMsgp bool) (v2 interface{}) {
+	if isMsgp {
+		if v >= 0 && v <= 127 {
+			v2 = uint64(v)
+		} else {
+			v2 = int64(v)
+		}
+	} else if v >= 0 {
+		v2 = uint64(v)
+	} else {
+		v2 = int64(v)
+	}
+	return
+}
+
+func testVerifyVal(v interface{}, f testVerifyFlag, h Handle) (v2 interface{}) {
+	//for python msgpack,
+	//  - all positive integers are unsigned 64-bit ints
+	//  - all floats are float64
+	_, isMsgp := h.(*MsgpackHandle)
+	_, isCbor := h.(*CborHandle)
+	switch iv := v.(type) {
+	case int8:
+		v2 = testVerifyValInt(int64(iv), isMsgp)
+		// fmt.Printf(">>>> is msgp: %v, v: %T, %v ==> v2: %T, %v\n", isMsgp, v, v, v2, v2)
+	case int16:
+		v2 = testVerifyValInt(int64(iv), isMsgp)
+	case int32:
+		v2 = testVerifyValInt(int64(iv), isMsgp)
+	case int64:
+		v2 = testVerifyValInt(int64(iv), isMsgp)
+	case uint8:
+		v2 = uint64(iv)
+	case uint16:
+		v2 = uint64(iv)
+	case uint32:
+		v2 = uint64(iv)
+	case uint64:
+		v2 = uint64(iv)
+	case float32:
+		v2 = float64(iv)
+	case float64:
+		v2 = float64(iv)
+	case []interface{}:
+		m2 := make([]interface{}, len(iv))
+		for j, vj := range iv {
+			m2[j] = testVerifyVal(vj, f, h)
+		}
+		v2 = m2
+	case testMbsT:
+		m2 := make([]interface{}, len(iv))
+		for j, vj := range iv {
+			m2[j] = testVerifyVal(vj, f, h)
+		}
+		v2 = testMbsT(m2)
+	case map[string]bool:
+		switch {
+		case f.isset(testVerifyMapTypeSame):
+			m2 := make(map[string]bool)
+			for kj, kv := range iv {
+				m2[kj] = kv
+			}
+			v2 = m2
+		case f.isset(testVerifyMapTypeStrIntf):
+			m2 := make(map[string]interface{})
+			for kj, kv := range iv {
+				m2[kj] = kv
+			}
+			v2 = m2
+		case f.isset(testVerifyMapTypeIntfIntf):
+			m2 := make(map[interface{}]interface{})
+			for kj, kv := range iv {
+				m2[kj] = kv
+			}
+			v2 = m2
+		}
+	case map[string]interface{}:
+		switch {
+		case f.isset(testVerifyMapTypeSame):
+			m2 := make(map[string]interface{})
+			for kj, kv := range iv {
+				m2[kj] = testVerifyVal(kv, f, h)
+			}
+			v2 = m2
+		case f.isset(testVerifyMapTypeStrIntf):
+			m2 := make(map[string]interface{})
+			for kj, kv := range iv {
+				m2[kj] = testVerifyVal(kv, f, h)
+			}
+			v2 = m2
+		case f.isset(testVerifyMapTypeIntfIntf):
+			m2 := make(map[interface{}]interface{})
+			for kj, kv := range iv {
+				m2[kj] = testVerifyVal(kv, f, h)
+			}
+			v2 = m2
+		}
+	case map[interface{}]interface{}:
+		m2 := make(map[interface{}]interface{})
+		for kj, kv := range iv {
+			m2[testVerifyVal(kj, f, h)] = testVerifyVal(kv, f, h)
+		}
+		v2 = m2
+	case time.Time:
+		switch {
+		case f.isset(testVerifyTimeAsInteger):
+			if iv2 := iv.UnixNano(); iv2 >= 0 {
+				v2 = uint64(iv2)
+			} else {
+				v2 = int64(iv2)
+			}
+		case isMsgp:
+			v2 = iv.UTC()
+		case isCbor:
+			// fmt.Printf("%%%% cbor verifier\n")
+			v2 = iv.UTC().Round(time.Microsecond)
 		default:
-			av[i] = v
+			v2 = v
 		}
+	default:
+		v2 = v
 	}
-
-	av = tableTestNilVerify
-	for i, v := range table {
-		if i > lp {
-			av[i] = skipVerifyVal
-			continue
-		}
-		av[i] = testVerifyVal(v, testVerifyMapTypeStrIntf)
-	}
-
-	av = tablePythonVerify
-	for i, v := range table {
-		if i == testTableNumPrimitives+1 || i > lp { // testTableNumPrimitives+1 is the mapBySlice
-			av[i] = skipVerifyVal
-			continue
-		}
-		av[i] = testVerifyVal(v, testVerifyForPython)
-	}
-
-	// only do the python verify up to the maps, skipping the last 2 maps.
-	tablePythonVerify = tablePythonVerify[:testTableNumPrimitives+2+testTableNumMaps-2]
+	return
 }
 
 func testUnmarshal(v interface{}, data []byte, h Handle) (err error) {
@@ -522,30 +686,37 @@ func testMarshal(v interface{}, h Handle) (bs []byte, err error) {
 	return testCodecEncode(v, nil, testByteBuf, h)
 }
 
-func testMarshalErr(v interface{}, h Handle, t *testing.T, name string) (bs []byte, err error) {
-	if bs, err = testMarshal(v, h); err != nil {
-		logT(t, "Error encoding %s: %v, Err: %v", name, v, err)
-		failT(t)
+func testMarshalErr(v interface{}, h Handle, t *testing.T, name string) (bs []byte) {
+	bs, err := testMarshal(v, h)
+	if err != nil {
+		failT(t, "Error encoding %s: %v, Err: %v", name, v, err)
 	}
 	return
 }
 
-func testUnmarshalErr(v interface{}, data []byte, h Handle, t *testing.T, name string) (err error) {
-	if err = testUnmarshal(v, data, h); err != nil {
-		logT(t, "Error Decoding into %s: %v, Err: %v", name, v, err)
-		failT(t)
+func testUnmarshalErr(v interface{}, data []byte, h Handle, t *testing.T, name string) {
+	if err := testUnmarshal(v, data, h); err != nil {
+		failT(t, "Error Decoding into %s: %v, Err: %v", name, v, err)
 	}
-	return
 }
 
-func testDeepEqualErr(v1, v2 interface{}, t *testing.T, name string) (err error) {
-	if err = deepEqual(v1, v2); err == nil {
+func testDeepEqualErr(v1, v2 interface{}, t *testing.T, name string) {
+	if err := deepEqual(v1, v2); err == nil {
 		logT(t, "%s: values equal", name)
 	} else {
-		logT(t, "%s: values not equal: %v. 1: %v, 2: %v", name, err, v1, v2)
-		failT(t)
+		failT(t, "%s: values not equal: %v. 1: %v, 2: %v", name, err, v1, v2)
 	}
-	return
+}
+
+func testReadWriteCloser(c io.ReadWriteCloser) io.ReadWriteCloser {
+	if testRpcBufsize <= 0 && rand.Int63()%2 == 0 {
+		return c
+	}
+	return struct {
+		io.Closer
+		*bufio.Reader
+		*bufio.Writer
+	}{c, bufio.NewReaderSize(c, testRpcBufsize), bufio.NewWriterSize(c, testRpcBufsize)}
 }
 
 // doTestCodecTableOne allows us test for different variations based on arguments passed.
@@ -557,40 +728,44 @@ func doTestCodecTableOne(t *testing.T, testNil bool, h Handle,
 	for i, v0 := range vs {
 		logT(t, "..............................................")
 		logT(t, "         Testing: #%d:, %T, %#v\n", i, v0, v0)
-		b0, err := testMarshalErr(v0, h, t, "v0")
-		if err != nil {
-			continue
+		b0 := testMarshalErr(v0, h, t, "v0")
+		var b1 = b0
+		if len(b1) > 256 {
+			b1 = b1[:256]
 		}
 		if h.isBinary() {
-			logT(t, "         Encoded bytes: len: %v, %v\n", len(b0), b0)
+			logT(t, "         Encoded bytes: len: %v, %v\n", len(b0), b1)
 		} else {
-			logT(t, "         Encoded string: len: %v, %v\n", len(string(b0)), string(b0))
+			logT(t, "         Encoded string: len: %v, %v\n", len(b0), string(b1))
 			// println("########### encoded string: " + string(b0))
 		}
 		var v1 interface{}
-
+		var err error
 		if testNil {
 			err = testUnmarshal(&v1, b0, h)
 		} else {
 			if v0 != nil {
 				v0rt := reflect.TypeOf(v0) // ptr
-				rv1 := reflect.New(v0rt)
-				err = testUnmarshal(rv1.Interface(), b0, h)
-				v1 = rv1.Elem().Interface()
-				// v1 = reflect.Indirect(reflect.ValueOf(v1)).Interface()
+				if v0rt.Kind() == reflect.Ptr {
+					err = testUnmarshal(v0, b0, h)
+					v1 = v0
+				} else {
+					rv1 := reflect.New(v0rt)
+					err = testUnmarshal(rv1.Interface(), b0, h)
+					v1 = rv1.Elem().Interface()
+					// v1 = reflect.Indirect(reflect.ValueOf(v1)).Interface()
+				}
 			}
 		}
 
-		logT(t, "         v1 returned: %T, %#v", v1, v1)
+		logT(t, "         v1 returned: %T, %v %#v", v1, v1, v1)
 		// if v1 != nil {
 		//	logT(t, "         v1 returned: %T, %#v", v1, v1)
 		//	//we always indirect, because ptr to typed value may be passed (if not testNil)
 		//	v1 = reflect.Indirect(reflect.ValueOf(v1)).Interface()
 		// }
 		if err != nil {
-			logT(t, "-------- Error: %v. Partial return: %v", err, v1)
-			failT(t)
-			continue
+			failT(t, "-------- Error: %v. Partial return: %v", err, v1)
 		}
 		v0check := vsVerify[i]
 		if v0check == skipVerifyVal {
@@ -603,9 +778,9 @@ func doTestCodecTableOne(t *testing.T, testNil bool, h Handle,
 		} else {
 			// logT(t, "-------- Before and After marshal do not match: Error: %v"+
 			// 	" ====> GOLDEN: (%T) %#v, DECODED: (%T) %#v\n", err, v0check, v0check, v1, v1)
-			logT(t, "-------- Before and After marshal do not match: Error: %v", err)
-			logT(t, "    ....... GOLDEN:  (%T) %#v", v0check, v0check)
-			logT(t, "    ....... DECODED: (%T) %#v", v1, v1)
+			logT(t, "-------- FAIL: Before and After marshal do not match: Error: %v", err)
+			logT(t, "    ....... GOLDEN:  (%T) %v %#v", v0check, v0check, v0check)
+			logT(t, "    ....... DECODED: (%T) %v %#v", v1, v1, v1)
 			failT(t)
 		}
 	}
@@ -619,13 +794,18 @@ func testCodecTableOne(t *testing.T, h Handle) {
 	numPrim, numMap, idxTime, idxMap := testTableNumPrimitives, testTableNumMaps, testTableIdxTime, testTableNumPrimitives+2
 
 	//println("#################")
+	tableVerify := testTableVerify(testVerifyMapTypeSame, h)
+	tableTestNilVerify := testTableVerify(testVerifyDoNil|testVerifyMapTypeStrIntf, h)
 	switch v := h.(type) {
 	case *MsgpackHandle:
 		var oldWriteExt, oldRawToString bool
+		_, _ = oldWriteExt, oldRawToString
 		oldWriteExt, v.WriteExt = v.WriteExt, true
 		oldRawToString, v.RawToString = v.RawToString, true
+		// defer func() { v.WriteExt, v.RawToString = oldWriteExt, oldRawToString }()
 		doTestCodecTableOne(t, false, h, table, tableVerify)
-		v.WriteExt, v.RawToString = oldWriteExt, oldRawToString
+		v.WriteExt = oldWriteExt
+		v.RawToString = oldRawToString
 	case *JsonHandle:
 		//skip []interface{} containing time.Time, as it encodes as a number, but cannot decode back to time.Time.
 		//As there is no real support for extension tags in json, this must be skipped.
@@ -644,13 +824,11 @@ func testCodecTableOne(t *testing.T, h Handle) {
 	v := h.getBasicHandle()
 
 	oldMapType, v.MapType = v.MapType, testMapStrIntfTyp
-
+	// defer func() { v.MapType = oldMapType }()
 	//skip time.Time, []interface{} containing time.Time, last map, and newStruc
 	doTestCodecTableOne(t, true, h, table[:idxTime], tableTestNilVerify[:idxTime])
-	doTestCodecTableOne(t, true, h, table[idxMap:idxMap+numMap-1], tableTestNilVerify[idxMap:idxMap+numMap-1])
-
+	doTestCodecTableOne(t, true, h, table[idxMap:idxMap+numMap-1], tableTestNilVerify[idxMap:idxMap+numMap-1]) // failing one for msgpack
 	v.MapType = oldMapType
-
 	// func TestMsgpackNilIntf(t *testing.T) {
 
 	//do last map and newStruc
@@ -661,35 +839,40 @@ func testCodecTableOne(t *testing.T, h Handle) {
 }
 
 func testCodecMiscOne(t *testing.T, h Handle) {
+	var err error
 	testOnce.Do(testInitAll)
-	b, err := testMarshalErr(32, h, t, "32")
+	b := testMarshalErr(32, h, t, "32")
 	// Cannot do this nil one, because faster type assertion decoding will panic
 	// var i *int32
 	// if err = testUnmarshal(b, i, nil); err == nil {
 	// 	logT(t, "------- Expecting error because we cannot unmarshal to int32 nil ptr")
 	// 	failT(t)
 	// }
-	var i2 int32 = 0
-	err = testUnmarshalErr(&i2, b, h, t, "int32-ptr")
+	var i2 int32
+	testUnmarshalErr(&i2, b, h, t, "int32-ptr")
 	if i2 != int32(32) {
 		logT(t, "------- didn't unmarshal to 32: Received: %d", i2)
 		failT(t)
 	}
 
 	// func TestMsgpackDecodePtr(t *testing.T) {
-	ts := newTestStruc(0, false, !testSkipIntf, false)
-	b, err = testMarshalErr(ts, h, t, "pointer-to-struct")
+	ts := newTestStrucFlex(testDepth, testNumRepeatString, false, !testSkipIntf, false)
+	b = testMarshalErr(ts, h, t, "pointer-to-struct")
 	if len(b) < 40 {
 		logT(t, "------- Size must be > 40. Size: %d", len(b))
 		failT(t)
 	}
-	if h.isBinary() {
-		logT(t, "------- b: %v", b)
-	} else {
-		logT(t, "------- b: %s", b)
+	var b1 = b
+	if len(b1) > 256 {
+		b1 = b1[:256]
 	}
-	ts2 := new(TestStruc)
-	err = testUnmarshalErr(ts2, b, h, t, "pointer-to-struct")
+	if h.isBinary() {
+		logT(t, "------- b: size: %v, value: %v", len(b), b1)
+	} else {
+		logT(t, "------- b: size: %v, value: %s", len(b), b1)
+	}
+	ts2 := new(TestStrucFlex)
+	testUnmarshalErr(ts2, b, h, t, "pointer-to-struct")
 	if ts2.I64 != math.MaxInt64*2/3 {
 		logT(t, "------- Unmarshal wrong. Expect I64 = 64. Got: %v", ts2.I64)
 		failT(t)
@@ -698,16 +881,17 @@ func testCodecMiscOne(t *testing.T, h Handle) {
 	// func TestMsgpackIntfDecode(t *testing.T) {
 	m := map[string]int{"A": 2, "B": 3}
 	p := []interface{}{m}
-	bs, err := testMarshalErr(p, h, t, "p")
+	bs := testMarshalErr(p, h, t, "p")
 
 	m2 := map[string]int{}
 	p2 := []interface{}{m2}
-	err = testUnmarshalErr(&p2, bs, h, t, "&p2")
+	testUnmarshalErr(&p2, bs, h, t, "&p2")
 
 	if m2["A"] != 2 || m2["B"] != 3 {
-		logT(t, "m2 not as expected: expecting: %v, got: %v", m, m2)
+		logT(t, "FAIL: m2 not as expected: expecting: %v, got: %v", m, m2)
 		failT(t)
 	}
+
 	// log("m: %v, m2: %v, p: %v, p2: %v", m, m2, p, p2)
 	checkEqualT(t, p, p2, "p=p2")
 	checkEqualT(t, m, m2, "m=m2")
@@ -727,7 +911,7 @@ func testCodecMiscOne(t *testing.T, h Handle) {
 	// func TestMsgpackDecodeStructSubset(t *testing.T) {
 	// test that we can decode a subset of the stream
 	mm := map[string]interface{}{"A": 5, "B": 99, "C": 333}
-	bs, err = testMarshalErr(mm, h, t, "mm")
+	bs = testMarshalErr(mm, h, t, "mm")
 	type ttt struct {
 		A uint8
 		C int32
@@ -748,18 +932,13 @@ func testCodecMiscOne(t *testing.T, h Handle) {
 	var tarr0 = tarr{1, [3]int64{2, 3, 4}, []byte{4, 5, 6}, [3]byte{7, 8, 9}}
 	// test both pointer and non-pointer (value)
 	for _, tarr1 := range []interface{}{tarr0, &tarr0} {
-		bs, err = testMarshalErr(tarr1, h, t, "tarr1")
-		if err != nil {
-			logT(t, "Error marshalling: %v", err)
-			failT(t)
-		}
+		bs = testMarshalErr(tarr1, h, t, "tarr1")
 		if _, ok := h.(*JsonHandle); ok {
 			logT(t, "Marshal as: %s", bs)
 		}
 		var tarr2 tarr
 		testUnmarshalErr(&tarr2, bs, h, t, "tarr2")
 		checkEqualT(t, tarr0, tarr2, "tarr0=tarr2")
-		// fmt.Printf(">>>> err: %v. tarr1: %v, tarr2: %v\n", err, tarr0, tarr2)
 	}
 
 	// test byte array, even if empty (msgpack only)
@@ -770,6 +949,19 @@ func testCodecMiscOne(t *testing.T, h Handle) {
 		var ya = ystruct{}
 		testUnmarshalErr(&ya, []byte{0x91, 0x90}, h, t, "ya")
 	}
+
+	var tt1, tt2 time.Time
+	tt2 = time.Now()
+	bs = testMarshalErr(tt1, h, t, "zero-time-enc")
+	testUnmarshalErr(&tt2, bs, h, t, "zero-time-dec")
+	testDeepEqualErr(tt1, tt2, t, "zero-time-eq")
+
+	// test encoding a slice of byte (but not []byte) and decoding into a []byte
+	var sw = []wrapUint8{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'}
+	var bw []byte // ("ABCDEFGHIJ")
+	bs = testMarshalErr(sw, h, t, "wrap-bytes-enc")
+	testUnmarshalErr(&bw, bs, h, t, "wrap-bytes-dec")
+	testDeepEqualErr(bw, []byte("ABCDEFGHIJ"), t, "wrap-bytes-eq")
 }
 
 func testCodecEmbeddedPointer(t *testing.T, h Handle) {
@@ -785,12 +977,10 @@ func testCodecEmbeddedPointer(t *testing.T, h Handle) {
 	}
 	var z Z = 4
 	x1 := &B{&z, &A{5}, 6}
-	bs, err := testMarshalErr(x1, h, t, "x1")
-	// fmt.Printf("buf: len(%v): %x\n", buf.Len(), buf.Bytes())
+	bs := testMarshalErr(x1, h, t, "x1")
 	var x2 = new(B)
-	err = testUnmarshalErr(x2, bs, h, t, "x2")
-	err = checkEqualT(t, x1, x2, "x1=x2")
-	_ = err
+	testUnmarshalErr(x2, bs, h, t, "x2")
+	checkEqualT(t, x1, x2, "x1=x2")
 }
 
 func testCodecUnderlyingType(t *testing.T, h Handle) {
@@ -816,40 +1006,120 @@ func testCodecUnderlyingType(t *testing.T, h Handle) {
 }
 
 func testCodecChan(t *testing.T, h Handle) {
+	testOnce.Do(testInitAll)
 	// - send a slice []*int64 (sl1) into an chan (ch1) with cap > len(s1)
 	// - encode ch1 as a stream array
 	// - decode a chan (ch2), with cap > len(s1) from the stream array
 	// - receive from ch2 into slice sl2
 	// - compare sl1 and sl2
 	// - do this for codecs: json, cbor (covers all types)
-	sl1 := make([]*int64, 4)
-	for i := range sl1 {
-		var j int64 = int64(i)
-		sl1[i] = &j
+
+	if true {
+		logT(t, "*int64")
+		sl1 := make([]*int64, 4)
+		for i := range sl1 {
+			var j int64 = int64(i)
+			sl1[i] = &j
+		}
+		ch1 := make(chan *int64, 4)
+		for _, j := range sl1 {
+			ch1 <- j
+		}
+		var bs []byte
+		NewEncoderBytes(&bs, h).MustEncode(ch1)
+		ch2 := make(chan *int64, 8)
+		NewDecoderBytes(bs, h).MustDecode(&ch2)
+		close(ch2)
+		var sl2 []*int64
+		for j := range ch2 {
+			sl2 = append(sl2, j)
+		}
+		if err := deepEqual(sl1, sl2); err != nil {
+			logT(t, "FAIL: Not Match: %v; len: %v, %v", err, len(sl1), len(sl2))
+			failT(t)
+		}
 	}
-	ch1 := make(chan *int64, 4)
-	for _, j := range sl1 {
-		ch1 <- j
+
+	if true {
+		logT(t, "testBytesT []byte - input []byte")
+		type testBytesT []byte
+		sl1 := make([]testBytesT, 4)
+		for i := range sl1 {
+			var j = []byte(strings.Repeat(strconv.FormatInt(int64(i), 10), i))
+			sl1[i] = j
+		}
+		ch1 := make(chan testBytesT, 4)
+		for _, j := range sl1 {
+			ch1 <- j
+		}
+		var bs []byte
+		NewEncoderBytes(&bs, h).MustEncode(ch1)
+		ch2 := make(chan testBytesT, 8)
+		NewDecoderBytes(bs, h).MustDecode(&ch2)
+		close(ch2)
+		var sl2 []testBytesT
+		for j := range ch2 {
+			// logT(t, ">>>> from chan: is nil? %v, %v", j == nil, j)
+			sl2 = append(sl2, j)
+		}
+		if err := deepEqual(sl1, sl2); err != nil {
+			logT(t, "FAIL: Not Match: %v; len: %v, %v", err, len(sl1), len(sl2))
+			failT(t)
+		}
 	}
-	var bs []byte
-	NewEncoderBytes(&bs, h).MustEncode(ch1)
-	// if !h.isBinary() {
-	// 	fmt.Printf("before: len(ch1): %v, bs: %s\n", len(ch1), bs)
-	// }
-	// var ch2 chan *int64 // this will block if json, etc.
-	ch2 := make(chan *int64, 8)
-	NewDecoderBytes(bs, h).MustDecode(&ch2)
-	// logT(t, "Len(ch2): %v", len(ch2))
-	// fmt.Printf("after:  len(ch2): %v, ch2: %v\n", len(ch2), ch2)
-	close(ch2)
-	var sl2 []*int64
-	for j := range ch2 {
-		sl2 = append(sl2, j)
+	if true {
+		logT(t, "testBytesT byte - input string/testBytesT")
+		type testBytesT byte
+		sl1 := make([]testBytesT, 4)
+		for i := range sl1 {
+			var j = strconv.FormatInt(int64(i), 10)[0]
+			sl1[i] = testBytesT(j)
+		}
+		ch1 := make(chan testBytesT, 4)
+		for _, j := range sl1 {
+			ch1 <- j
+		}
+		var bs []byte
+		NewEncoderBytes(&bs, h).MustEncode(ch1)
+		ch2 := make(chan testBytesT, 8)
+		NewDecoderBytes(bs, h).MustDecode(&ch2)
+		close(ch2)
+		var sl2 []testBytesT
+		for j := range ch2 {
+			sl2 = append(sl2, j)
+		}
+		if err := deepEqual(sl1, sl2); err != nil {
+			logT(t, "FAIL: Not Match: %v; len: %v, %v", err, len(sl1), len(sl2))
+			failT(t)
+		}
 	}
-	if err := deepEqual(sl1, sl2); err != nil {
-		logT(t, "Not Match: %v; len: %v, %v", err, len(sl1), len(sl2))
-		failT(t)
+
+	if true {
+		logT(t, "*[]byte")
+		sl1 := make([]byte, 4)
+		for i := range sl1 {
+			var j = strconv.FormatInt(int64(i), 10)[0]
+			sl1[i] = byte(j)
+		}
+		ch1 := make(chan byte, 4)
+		for _, j := range sl1 {
+			ch1 <- j
+		}
+		var bs []byte
+		NewEncoderBytes(&bs, h).MustEncode(ch1)
+		ch2 := make(chan byte, 8)
+		NewDecoderBytes(bs, h).MustDecode(&ch2)
+		close(ch2)
+		var sl2 []byte
+		for j := range ch2 {
+			sl2 = append(sl2, j)
+		}
+		if err := deepEqual(sl1, sl2); err != nil {
+			logT(t, "FAIL: Not Match: %v; len: %v, %v", err, len(sl1), len(sl2))
+			failT(t)
+		}
 	}
+
 }
 
 func testCodecRpcOne(t *testing.T, rr Rpc, h Handle, doRequest bool, exitSleepMs time.Duration,
@@ -863,6 +1133,11 @@ func testCodecRpcOne(t *testing.T, rr Rpc, h Handle, doRequest bool, exitSleepMs
 		logT(t, "EXPECTED. set recoverPanicToErr=true, since rpc needs EOF")
 		failT(t)
 	}
+
+	if jsonH, ok := h.(*JsonHandle); ok && !jsonH.TermWhitespace {
+		jsonH.TermWhitespace = true
+		defer func() { jsonH.TermWhitespace = false }()
+	}
 	srv := rpc.NewServer()
 	srv.Register(testRpcInt)
 	ln, err := net.Listen("tcp", "127.0.0.1:0")
@@ -874,7 +1149,7 @@ func testCodecRpcOne(t *testing.T, rr Rpc, h Handle, doRequest bool, exitSleepMs
 	// opts.MapType = mapStrIntfTyp
 	// opts.RawToString = false
 	serverExitChan := make(chan bool, 1)
-	var serverExitFlag uint64 = 0
+	var serverExitFlag uint64
 	serverFn := func() {
 		for {
 			conn1, err1 := ln.Accept()
@@ -888,7 +1163,7 @@ func testCodecRpcOne(t *testing.T, rr Rpc, h Handle, doRequest bool, exitSleepMs
 				return // exit serverFn goroutine
 			}
 			if err1 == nil {
-				var sc rpc.ServerCodec = rr.ServerCodec(conn1, h)
+				sc := rr.ServerCodec(testReadWriteCloser(conn1), h)
 				srv.ServeCodec(sc)
 			}
 		}
@@ -918,7 +1193,6 @@ func testCodecRpcOne(t *testing.T, rr Rpc, h Handle, doRequest bool, exitSleepMs
 	connFn := func() (bs net.Conn) {
 		// log("calling f1")
 		bs, err2 := net.Dial(ln.Addr().Network(), ln.Addr().String())
-		//fmt.Printf("f1. bs: %v, err2: %v\n", bs, err2)
 		checkErrT(t, err2)
 		return
 	}
@@ -940,7 +1214,7 @@ func testCodecRpcOne(t *testing.T, rr Rpc, h Handle, doRequest bool, exitSleepMs
 	}
 	if doRequest {
 		bs := connFn()
-		cc := rr.ClientCodec(bs, h)
+		cc := rr.ClientCodec(testReadWriteCloser(bs), h)
 		clientFn(cc)
 	}
 	if exitSleepMs != 0 {
@@ -954,10 +1228,12 @@ func testCodecRpcOne(t *testing.T, rr Rpc, h Handle, doRequest bool, exitSleepMs
 }
 
 func doTestMapEncodeForCanonical(t *testing.T, name string, h Handle) {
-	v1 := map[string]interface{}{
-		"a": 1,
-		"b": "hello",
-		"c": map[string]interface{}{
+	testOnce.Do(testInitAll)
+	// println("doTestMapEncodeForCanonical")
+	v1 := map[stringUint64T]interface{}{
+		{"a", 1}: 1,
+		{"b", 2}: "hello",
+		{"c", 3}: map[string]interface{}{
 			"c/a": 1,
 			"c/b": "world",
 			"c/c": []int{1, 2, 3, 4},
@@ -983,13 +1259,26 @@ func doTestMapEncodeForCanonical(t *testing.T, name string, h Handle) {
 				"4444":  4444,
 				"55555": 55555,
 			},
+			"c/g": map[bool]int{
+				false: 0,
+				true:  1,
+			},
 		},
 	}
-	var v2 map[string]interface{}
-	var b1, b2 []byte
+	var v2 map[stringUint64T]interface{}
+	var b1, b2, b3 []byte
 
-	// encode v1 into b1, decode b1 into v2, encode v2 into b2, compare b1 and b2
+	// encode v1 into b1, decode b1 into v2, encode v2 into b2, and compare b1 and b2.
+	// OR
+	// encode v1 into b1, decode b1 into v2, encode v2 into b2 and b3, and compare b2 and b3.
+	//   e.g. when doing cbor indefinite, we may haveto use out-of-band encoding
+	//   where each key is encoded as an indefinite length string, which makes it not the same
+	//   order as the strings were lexicographically ordered before.
 
+	var cborIndef bool
+	if ch, ok := h.(*CborHandle); ok {
+		cborIndef = ch.IndefiniteLength
+	}
 	bh := h.getBasicHandle()
 	if !bh.Canonical {
 		bh.Canonical = true
@@ -1000,15 +1289,24 @@ func doTestMapEncodeForCanonical(t *testing.T, name string, h Handle) {
 	e1.MustEncode(v1)
 	d1 := NewDecoderBytes(b1, h)
 	d1.MustDecode(&v2)
+	// testDeepEqualErr(v1, v2, t, "huh?")
 	e2 := NewEncoderBytes(&b2, h)
 	e2.MustEncode(v2)
-	if !bytes.Equal(b1, b2) {
-		logT(t, "Unequal bytes: %v VS %v", b1, b2)
+	var b1t, b2t = b1, b2
+	if cborIndef {
+		e2 = NewEncoderBytes(&b3, h)
+		e2.MustEncode(v2)
+		b1t, b2t = b2, b3
+	}
+
+	if !bytes.Equal(b1t, b2t) {
+		logT(t, "Unequal bytes: %v VS %v", b1t, b2t)
 		failT(t)
 	}
 }
 
 func doTestStdEncIntf(t *testing.T, name string, h Handle) {
+	testOnce.Do(testInitAll)
 	args := [][2]interface{}{
 		{&TestABC{"A", "BB", "CCC"}, new(TestABC)},
 		{&TestABC2{"AAA", "BB", "C"}, new(TestABC2)},
@@ -1022,13 +1320,14 @@ func doTestStdEncIntf(t *testing.T, name string, h Handle) {
 		if err := deepEqual(a[0], a[1]); err == nil {
 			logT(t, "++++ Objects match")
 		} else {
-			logT(t, "---- Objects do not match: y1: %v, err: %v", a[1], err)
+			logT(t, "---- FAIL: Objects do not match: y1: %v, err: %v", a[1], err)
 			failT(t)
 		}
 	}
 }
 
 func doTestEncCircularRef(t *testing.T, name string, h Handle) {
+	testOnce.Do(testInitAll)
 	type T1 struct {
 		S string
 		B bool
@@ -1063,7 +1362,7 @@ func doTestEncCircularRef(t *testing.T, name string, h Handle) {
 	if x := err.Error(); strings.Contains(x, "circular") || strings.Contains(x, "cyclic") {
 		logT(t, "error detected as expected: %v", x)
 	} else {
-		logT(t, "error detected was not as expected: %v", x)
+		logT(t, "FAIL: error detected was not as expected: %v", x)
 		failT(t)
 	}
 }
@@ -1085,6 +1384,7 @@ type (
 )
 
 func doTestAnonCycle(t *testing.T, name string, h Handle) {
+	testOnce.Do(testInitAll)
 	var x TestAnonCycleT1
 	x.S = "hello"
 	x.TestAnonCycleT2.S2 = "hello.2"
@@ -1098,6 +1398,7 @@ func doTestAnonCycle(t *testing.T, name string, h Handle) {
 }
 
 func doTestJsonLargeInteger(t *testing.T, v interface{}, ias uint8) {
+	testOnce.Do(testInitAll)
 	logT(t, "Running doTestJsonLargeInteger: v: %#v, ias: %c", v, ias)
 	oldIAS := testJsonH.IntegerAsString
 	defer func() { testJsonH.IntegerAsString = oldIAS }()
@@ -1163,11 +1464,11 @@ func doTestJsonLargeInteger(t *testing.T, v interface{}, ias uint8) {
 			logT(t, "Expecting equal values from %s: got golden: %v, decoded: %v", b, v2, vu)
 			failT(t)
 		}
-		// fmt.Printf("%v: %s, decode: %d, bool: %v, equal_on_decode: %v\n", v, b, vu, vb, vu == v.(uint))
 	}
 }
 
 func doTestRawValue(t *testing.T, name string, h Handle) {
+	testOnce.Do(testInitAll)
 	bh := h.getBasicHandle()
 	if !bh.Raw {
 		bh.Raw = true
@@ -1208,6 +1509,7 @@ func doTestRawValue(t *testing.T, name string, h Handle) {
 // We keep this unexported here, and put actual test in ext_dep_test.go.
 // This way, it can be excluded by excluding file completely.
 func doTestPythonGenStreams(t *testing.T, name string, h Handle) {
+	testOnce.Do(testInitAll)
 	logT(t, "TestPythonGenStreams-%v", name)
 	tmpdir, err := ioutil.TempDir("", "golang-"+name+"-test")
 	if err != nil {
@@ -1229,6 +1531,7 @@ func doTestPythonGenStreams(t *testing.T, name string, h Handle) {
 	bh := h.getBasicHandle()
 
 	oldMapType := bh.MapType
+	tablePythonVerify := testTableVerify(testVerifyForPython|testVerifyTimeAsInteger|testVerifyMapTypeStrIntf, h)
 	for i, v := range tablePythonVerify {
 		// if v == uint64(0) && h == testMsgpackH {
 		// 	v = int64(0)
@@ -1264,7 +1567,7 @@ func doTestPythonGenStreams(t *testing.T, name string, h Handle) {
 		if err = deepEqual(v, v1); err == nil {
 			logT(t, "++++++++ Objects match: %T, %v", v, v)
 		} else {
-			logT(t, "-------- Objects do not match: %v. Source: %T. Decoded: %T", err, v, v1)
+			logT(t, "-------- FAIL: Objects do not match: %v. Source: %T. Decoded: %T", err, v, v1)
 			logT(t, "--------   GOLDEN: %#v", v)
 			// logT(t, "--------   DECODED: %#v <====> %#v", v1, reflect.Indirect(reflect.ValueOf(v1)).Interface())
 			logT(t, "--------   DECODED: %#v <====> %#v", v1, reflect.Indirect(reflect.ValueOf(v1)).Interface())
@@ -1279,7 +1582,7 @@ func doTestPythonGenStreams(t *testing.T, name string, h Handle) {
 		if err = deepEqual(bsb, bss); err == nil {
 			logT(t, "++++++++ Bytes match")
 		} else {
-			logT(t, "???????? Bytes do not match. %v.", err)
+			logT(t, "???????? FAIL: Bytes do not match. %v.", err)
 			xs := "--------"
 			if reflect.ValueOf(v).Kind() == reflect.Map {
 				xs = "        "
@@ -1308,6 +1611,7 @@ func doTestMsgpackRpcSpecGoClientToPythonSvc(t *testing.T) {
 	if testSkipRPCTests {
 		return
 	}
+	testOnce.Do(testInitAll)
 	// openPorts are between 6700 and 6800
 	r := rand.New(rand.NewSource(time.Now().UnixNano()))
 	openPort := strconv.FormatInt(6700+r.Int63n(99), 10)
@@ -1320,7 +1624,7 @@ func doTestMsgpackRpcSpecGoClientToPythonSvc(t *testing.T) {
 		bs, err2 = net.Dial("tcp", ":"+openPort)
 	}
 	checkErrT(t, err2)
-	cc := MsgpackSpecRpc.ClientCodec(bs, testMsgpackH)
+	cc := MsgpackSpecRpc.ClientCodec(testReadWriteCloser(bs), testMsgpackH)
 	cl := rpc.NewClientWithCodec(cc)
 	defer cl.Close()
 	var rstr string
@@ -1336,6 +1640,7 @@ func doTestMsgpackRpcSpecPythonClientToGoSvc(t *testing.T) {
 	if testSkipRPCTests {
 		return
 	}
+	testOnce.Do(testInitAll)
 	port := testCodecRpcOne(t, MsgpackSpecRpc, testMsgpackH, false, 1*time.Second)
 	//time.Sleep(1000 * time.Millisecond)
 	cmd := exec.Command("python", "test.py", "rpc-client-go-service", strconv.Itoa(port))
@@ -1350,7 +1655,290 @@ func doTestMsgpackRpcSpecPythonClientToGoSvc(t *testing.T) {
 		fmt.Sprintf("%#v\n%#v\n", []string{"A1", "B2", "C3"}, TestRpcABC{"Aa", "Bb", "Cc"}), "cmdout=")
 }
 
+func doTestSwallowAndZero(t *testing.T, h Handle) {
+	testOnce.Do(testInitAll)
+	v1 := newTestStrucFlex(testDepth, testNumRepeatString, false, false, false)
+	var b1 []byte
+
+	e1 := NewEncoderBytes(&b1, h)
+	e1.MustEncode(v1)
+	d1 := NewDecoderBytes(b1, h)
+	d1.swallow()
+	if d1.r.numread() != len(b1) {
+		logT(t, "swallow didn't consume all encoded bytes: %v out of %v", d1.r.numread(), len(b1))
+		failT(t)
+	}
+	setZero(v1)
+	testDeepEqualErr(v1, &TestStrucFlex{}, t, "filled-and-zeroed")
+}
+
+func doTestRawExt(t *testing.T, h Handle) {
+	testOnce.Do(testInitAll)
+	var b []byte
+	var v RawExt // interface{}
+	_, isJson := h.(*JsonHandle)
+	_, isCbor := h.(*CborHandle)
+	bh := h.getBasicHandle()
+	// isValuer := isJson || isCbor
+	// _ = isValuer
+	for _, r := range []RawExt{
+		{Tag: 99, Value: "9999", Data: []byte("9999")},
+	} {
+		e := NewEncoderBytes(&b, h)
+		e.MustEncode(&r)
+		// fmt.Printf(">>>> rawext: isnil? %v, %d - %v\n", b == nil, len(b), b)
+		d := NewDecoderBytes(b, h)
+		d.MustDecode(&v)
+		var r2 = r
+		switch {
+		case isJson:
+			r2.Tag = 0
+			r2.Data = nil
+		case isCbor:
+			r2.Data = nil
+		default:
+			r2.Value = nil
+		}
+		testDeepEqualErr(v, r2, t, "rawext-default")
+		// switch h.(type) {
+		// case *JsonHandle:
+		// 	testDeepEqualErr(r.Value, v, t, "rawext-json")
+		// default:
+		// 	var r2 = r
+		// 	if isValuer {
+		// 		r2.Data = nil
+		// 	} else {
+		// 		r2.Value = nil
+		// 	}
+		// 	testDeepEqualErr(v, r2, t, "rawext-default")
+		// }
+	}
+
+	// Add testing for Raw also
+	if b != nil {
+		b = b[:0]
+	}
+	oldRawMode := bh.Raw
+	defer func() { bh.Raw = oldRawMode }()
+	bh.Raw = true
+
+	var v2 Raw
+	for _, s := range []string{
+		"goodbye",
+		"hello",
+	} {
+		e := NewEncoderBytes(&b, h)
+		e.MustEncode(&s)
+		// fmt.Printf(">>>> rawext: isnil? %v, %d - %v\n", b == nil, len(b), b)
+		var r Raw = make([]byte, len(b))
+		copy(r, b)
+		d := NewDecoderBytes(b, h)
+		d.MustDecode(&v2)
+		testDeepEqualErr(v2, r, t, "raw-default")
+	}
+
+}
+
+// func doTestTimeExt(t *testing.T, h Handle) {
+// 	var t = time.Now()
+// 	// add time ext to the handle
+// }
+
+func doTestMapStructKey(t *testing.T, h Handle) {
+	testOnce.Do(testInitAll)
+	var b []byte
+	var v interface{} // map[stringUint64T]wrapUint64Slice // interface{}
+	bh := h.getBasicHandle()
+	m := map[stringUint64T]wrapUint64Slice{
+		{"55555", 55555}: []wrapUint64{12345},
+		{"333", 333}:     []wrapUint64{123},
+	}
+	oldCanonical := bh.Canonical
+	oldMapType := bh.MapType
+	defer func() {
+		bh.Canonical = oldCanonical
+		bh.MapType = oldMapType
+	}()
+
+	bh.MapType = reflect.TypeOf((*map[stringUint64T]wrapUint64Slice)(nil)).Elem()
+	for _, bv := range [2]bool{true, false} {
+		b, v = nil, nil
+		bh.Canonical = bv
+		e := NewEncoderBytes(&b, h)
+		e.MustEncode(m)
+		d := NewDecoderBytes(b, h)
+		d.MustDecode(&v)
+		testDeepEqualErr(v, m, t, "map-structkey")
+	}
+}
+
+func doTestDecodeNilMapValue(t *testing.T, handle Handle) {
+	testOnce.Do(testInitAll)
+	type Struct struct {
+		Field map[uint16]map[uint32]struct{}
+	}
+
+	bh := handle.getBasicHandle()
+	oldMapType := bh.MapType
+	oldDeleteOnNilMapValue := bh.DeleteOnNilMapValue
+	defer func() {
+		bh.MapType = oldMapType
+		bh.DeleteOnNilMapValue = oldDeleteOnNilMapValue
+	}()
+	bh.MapType = reflect.TypeOf(map[interface{}]interface{}(nil))
+	bh.DeleteOnNilMapValue = false
+
+	_, isJsonHandle := handle.(*JsonHandle)
+
+	toEncode := Struct{Field: map[uint16]map[uint32]struct{}{
+		1: nil,
+	}}
+
+	bs, err := testMarshal(toEncode, handle)
+	if err != nil {
+		logT(t, "Error encoding: %v, Err: %v", toEncode, err)
+		failT(t)
+	}
+	if isJsonHandle {
+		logT(t, "json encoded: %s\n", bs)
+	}
+
+	var decoded Struct
+	err = testUnmarshal(&decoded, bs, handle)
+	if err != nil {
+		logT(t, "Error decoding: %v", err)
+		failT(t)
+	}
+	if !reflect.DeepEqual(decoded, toEncode) {
+		logT(t, "Decoded value %#v != %#v", decoded, toEncode)
+		failT(t)
+	}
+}
+
+func doTestEmbeddedFieldPrecedence(t *testing.T, h Handle) {
+	testOnce.Do(testInitAll)
+	type Embedded struct {
+		Field byte
+	}
+	type Struct struct {
+		Field byte
+		Embedded
+	}
+	toEncode := Struct{
+		Field:    1,
+		Embedded: Embedded{Field: 2},
+	}
+	_, isJsonHandle := h.(*JsonHandle)
+	handle := h.getBasicHandle()
+	oldMapType := handle.MapType
+	defer func() { handle.MapType = oldMapType }()
+
+	handle.MapType = reflect.TypeOf(map[interface{}]interface{}(nil))
+
+	bs, err := testMarshal(toEncode, h)
+	if err != nil {
+		logT(t, "Error encoding: %v, Err: %v", toEncode, err)
+		failT(t)
+	}
+
+	var decoded Struct
+	err = testUnmarshal(&decoded, bs, h)
+	if err != nil {
+		logT(t, "Error decoding: %v", err)
+		failT(t)
+	}
+
+	if decoded.Field != toEncode.Field {
+		logT(t, "Decoded result %v != %v", decoded.Field, toEncode.Field) // hex to look at what was encoded
+		if isJsonHandle {
+			logT(t, "JSON encoded as: %s", bs) // hex to look at what was encoded
+		}
+		failT(t)
+	}
+}
+
+func doTestLargeContainerLen(t *testing.T, h Handle) {
+	testOnce.Do(testInitAll)
+	m := make(map[int][]struct{})
+	for i := range []int{
+		0, 1,
+		math.MaxInt8, math.MaxInt8 + 4, math.MaxInt8 - 4,
+		math.MaxInt16, math.MaxInt16 + 4, math.MaxInt16 - 4,
+		math.MaxInt32, math.MaxInt32 + 4, math.MaxInt32 - 4,
+		math.MaxInt64, math.MaxInt64 - 4,
+
+		math.MaxUint8, math.MaxUint8 + 4, math.MaxUint8 - 4,
+		math.MaxUint16, math.MaxUint16 + 4, math.MaxUint16 - 4,
+		math.MaxUint32, math.MaxUint32 + 4, math.MaxUint32 - 4,
+	} {
+		m[i] = make([]struct{}, i)
+	}
+	bs := testMarshalErr(m, h, t, "-")
+	var m2 = make(map[int][]struct{})
+	testUnmarshalErr(m2, bs, h, t, "-")
+	testDeepEqualErr(m, m2, t, "-")
+
+	// TODO: skip rest if 32-bit
+
+	// do same tests for large strings (encoded as symbols or not)
+	// skip if 32-bit or not using unsafe mode
+	if safeMode || (32<<(^uint(0)>>63)) < 64 {
+		return
+	}
+
+	// now, want to do tests for large strings, which
+	// could be encoded as symbols.
+	// to do this, we create a simple one-field struct,
+	// use use flags to switch from symbols to non-symbols
+
+	bh := h.getBasicHandle()
+	oldAsSymbols := bh.AsSymbols
+	defer func() { bh.AsSymbols = oldAsSymbols }()
+
+	var out []byte = make([]byte, 0, math.MaxUint16*3/2)
+	var in []byte = make([]byte, math.MaxUint16*3/2)
+	for i := range in {
+		in[i] = 'A'
+	}
+	e := NewEncoder(nil, h)
+	for _, i := range []int{
+		0, 1, 4, 8, 12, 16, 28, 32, 36,
+		math.MaxInt8, math.MaxInt8 + 4, math.MaxInt8 - 4,
+		math.MaxInt16, math.MaxInt16 + 4, math.MaxInt16 - 4,
+
+		math.MaxUint8, math.MaxUint8 + 4, math.MaxUint8 - 4,
+		math.MaxUint16, math.MaxUint16 + 4, math.MaxUint16 - 4,
+	} {
+		var m1, m2 map[string]bool
+		m1 = make(map[string]bool, 1)
+		var s1 = stringView(in[:i])
+		// fmt.Printf("testcontainerlen: large string: i: %v, |%s|\n", i, s1)
+		m1[s1] = true
+
+		bh.AsSymbols = AsSymbolNone
+		out = out[:0]
+		e.ResetBytes(&out)
+		e.MustEncode(m1)
+		// bs, _ = testMarshalErr(m1, h, t, "-")
+		m2 = make(map[string]bool, 1)
+		testUnmarshalErr(m2, out, h, t, "no-symbols")
+		testDeepEqualErr(m1, m2, t, "no-symbols")
+
+		// now, do as symbols
+		bh.AsSymbols = AsSymbolAll
+		out = out[:0]
+		e.ResetBytes(&out)
+		e.MustEncode(m1)
+		// bs, _ = testMarshalErr(m1, h, t, "-")
+		m2 = make(map[string]bool, 1)
+		testUnmarshalErr(m2, out, h, t, "symbols")
+		testDeepEqualErr(m1, m2, t, "symbols")
+	}
+
+}
+
 func testRandomFillRV(v reflect.Value) {
+	testOnce.Do(testInitAll)
 	fneg := func() int64 {
 		i := rand.Intn(1)
 		if i == 1 {
@@ -1408,11 +1996,7 @@ func testRandomFillRV(v reflect.Value) {
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
 		v.SetUint(uint64(rand.Int63n(255)))
 	case reflect.Bool:
-		if fneg() == 1 {
-			v.SetBool(true)
-		} else {
-			v.SetBool(false)
-		}
+		v.SetBool(fneg() == 1)
 	case reflect.Float32, reflect.Float64:
 		v.SetFloat(float64(fneg()) * float64(rand.Float32()))
 	case reflect.String:
@@ -1424,16 +2008,487 @@ func testRandomFillRV(v reflect.Value) {
 
 func testMammoth(t *testing.T, name string, h Handle) {
 	testOnce.Do(testInitAll)
+	var b []byte
+
 	var m, m2 TestMammoth
 	testRandomFillRV(reflect.ValueOf(&m).Elem())
-	b, _ := testMarshalErr(&m, h, t, "mammoth-"+name)
+	b = testMarshalErr(&m, h, t, "mammoth-"+name)
 	testUnmarshalErr(&m2, b, h, t, "mammoth-"+name)
-	// fmt.Printf("m2: %v", &m2)
 	testDeepEqualErr(&m, &m2, t, "mammoth-"+name)
+
+	var mm, mm2 TestMammoth2Wrapper
+	testRandomFillRV(reflect.ValueOf(&mm).Elem())
+	b = testMarshalErr(&mm, h, t, "mammoth2-"+name)
+	testUnmarshalErr(&mm2, b, h, t, "mammoth2-"+name)
+	testDeepEqualErr(&mm, &mm2, t, "mammoth2-"+name)
+	// testMammoth2(t, name, h)
+}
+
+func testTime(t *testing.T, name string, h Handle) {
+	testOnce.Do(testInitAll)
+	// test time which uses the time.go implementation (ie Binc)
+	var tt, tt2 time.Time
+	// time in 1990
+	tt = time.Unix(20*366*24*60*60, 1000*900).In(time.FixedZone("UGO", -5*60*60))
+	// fmt.Printf("time tt: %v\n", tt)
+	b := testMarshalErr(tt, h, t, "time-"+name)
+	testUnmarshalErr(&tt2, b, h, t, "time-"+name)
+	// per go documentation, test time with .Equal not ==
+	if !tt2.Equal(tt) {
+		logT(t, "%s: values not equal: 1: %v, 2: %v", name, tt2, tt)
+		failT(t)
+	}
+	// testDeepEqualErr(tt.UTC(), tt2, t, "time-"+name)
+}
+
+func testUintToInt(t *testing.T, name string, h Handle) {
+	testOnce.Do(testInitAll)
+	var golden = [...]int64{
+		0, 1, 22, 333, 4444, 55555, 666666,
+		// msgpack ones
+		24, 128,
+		// standard ones
+		math.MaxUint8, math.MaxUint8 + 4, math.MaxUint8 - 4,
+		math.MaxUint16, math.MaxUint16 + 4, math.MaxUint16 - 4,
+		math.MaxUint32, math.MaxUint32 + 4, math.MaxUint32 - 4,
+		math.MaxInt8, math.MaxInt8 + 4, math.MaxInt8 - 4,
+		math.MaxInt16, math.MaxInt16 + 4, math.MaxInt16 - 4,
+		math.MaxInt32, math.MaxInt32 + 4, math.MaxInt32 - 4,
+		math.MaxInt64, math.MaxInt64 - 4,
+	}
+	var ui uint64
+	var fi float64
+	var b []byte
+	for _, i := range golden {
+		ui = 0
+		b = testMarshalErr(i, h, t, "int2uint-"+name)
+		testUnmarshalErr(&ui, b, h, t, "int2uint-"+name)
+		if ui != uint64(i) {
+			logT(t, "%s: values not equal: %v, %v", name, ui, uint64(i))
+			failT(t)
+		}
+		i = 0
+		b = testMarshalErr(ui, h, t, "uint2int-"+name)
+		testUnmarshalErr(&i, b, h, t, "uint2int-"+name)
+		if i != int64(ui) {
+			logT(t, "%s: values not equal: %v, %v", name, i, int64(ui))
+			failT(t)
+		}
+		fi = 0
+		b = testMarshalErr(i, h, t, "int2float-"+name)
+		testUnmarshalErr(&fi, b, h, t, "int2float-"+name)
+		if fi != float64(i) {
+			logT(t, "%s: values not equal: %v, %v", name, fi, float64(i))
+			failT(t)
+		}
+	}
+}
+
+func doTestDifferentMapOrSliceType(t *testing.T, name string, h Handle) {
+	testOnce.Do(testInitAll)
+
+	// - maptype, slicetype: diff from map[string]intf, map[intf]intf or []intf, etc
+	//   include map[interface{}]string where some keys are []byte.
+	//   To test, take a sequence of []byte and string, and decode into []string and []interface.
+	//   Also, decode into map[string]string, map[string]interface{}, map[interface{}]string
+
+	bh := h.getBasicHandle()
+	oldM, oldS := bh.MapType, bh.SliceType
+	defer func() { bh.MapType, bh.SliceType = oldM, oldS }()
+
+	var b []byte
+
+	var vi = []interface{}{
+		"hello 1",
+		[]byte("hello 2"),
+		"hello 3",
+		[]byte("hello 4"),
+		"hello 5",
+	}
+	var vs []string
+	var v2i, v2s testMbsT
+	var v2ss testMbsCustStrT
+	// encode it as a map or as a slice
+	for i, v := range vi {
+		vv, ok := v.(string)
+		if !ok {
+			vv = string(v.([]byte))
+		}
+		vs = append(vs, vv)
+		v2i = append(v2i, v, strconv.FormatInt(int64(i+1), 10))
+		v2s = append(v2s, vv, strconv.FormatInt(int64(i+1), 10))
+		v2ss = append(v2ss, testCustomStringT(vv), testCustomStringT(strconv.FormatInt(int64(i+1), 10)))
+	}
+
+	var v2d interface{}
+
+	// encode vs as a list, and decode into a list and compare
+	var goldSliceS = []string{"hello 1", "hello 2", "hello 3", "hello 4", "hello 5"}
+	var goldSliceI = []interface{}{"hello 1", "hello 2", "hello 3", "hello 4", "hello 5"}
+	var goldSlice = []interface{}{goldSliceS, goldSliceI}
+	for j, g := range goldSlice {
+		bh.SliceType = reflect.TypeOf(g)
+		name := fmt.Sprintf("slice-%s-%v", name, j+1)
+		b = testMarshalErr(vs, h, t, name)
+		v2d = nil
+		// v2d = reflect.New(bh.SliceType).Elem().Interface()
+		testUnmarshalErr(&v2d, b, h, t, name)
+		testDeepEqualErr(v2d, goldSlice[j], t, name)
+	}
+
+	// to ensure that we do not use fast-path for map[intf]string, use a custom string type (for goldMapIS).
+	// this will allow us to test out the path that sees a []byte where a map has an interface{} type,
+	// and convert it to a string for the decoded map key.
+
+	// encode v2i as a map, and decode into a map and compare
+	var goldMapSS = map[string]string{"hello 1": "1", "hello 2": "2", "hello 3": "3", "hello 4": "4", "hello 5": "5"}
+	var goldMapSI = map[string]interface{}{"hello 1": "1", "hello 2": "2", "hello 3": "3", "hello 4": "4", "hello 5": "5"}
+	var goldMapIS = map[interface{}]testCustomStringT{"hello 1": "1", "hello 2": "2", "hello 3": "3", "hello 4": "4", "hello 5": "5"}
+	var goldMap = []interface{}{goldMapSS, goldMapSI, goldMapIS}
+	for j, g := range goldMap {
+		bh.MapType = reflect.TypeOf(g)
+		name := fmt.Sprintf("map-%s-%v", name, j+1)
+		// for formats that clearly differentiate binary from string, use v2i
+		// else use the v2s (with all strings, no []byte)
+		v2d = nil
+		// v2d = reflect.New(bh.MapType).Elem().Interface()
+		switch h.(type) {
+		case *MsgpackHandle, *BincHandle, *CborHandle:
+			b = testMarshalErr(v2i, h, t, name)
+			testUnmarshalErr(&v2d, b, h, t, name)
+			testDeepEqualErr(v2d, goldMap[j], t, name)
+		default:
+			b = testMarshalErr(v2s, h, t, name)
+			testUnmarshalErr(&v2d, b, h, t, name)
+			testDeepEqualErr(v2d, goldMap[j], t, name)
+			b = testMarshalErr(v2ss, h, t, name)
+			v2d = nil
+			testUnmarshalErr(&v2d, b, h, t, name)
+			testDeepEqualErr(v2d, goldMap[j], t, name)
+		}
+	}
+
+}
+
+func doTestScalars(t *testing.T, name string, h Handle) {
+	testOnce.Do(testInitAll)
+
+	// for each scalar:
+	// - encode its ptr
+	// - encode it (non-ptr)
+	// - check that bytes are same
+	// - make a copy (using reflect)
+	// - check that same
+	// - set zero on it
+	// - check that its equal to 0 value
+	// - decode into new
+	// - compare to original
+
+	bh := h.getBasicHandle()
+	if !bh.Canonical {
+		bh.Canonical = true
+		defer func() { bh.Canonical = false }()
+	}
+
+	vi := []interface{}{
+		int(0),
+		int8(0),
+		int16(0),
+		int32(0),
+		int64(0),
+		uint(0),
+		uint8(0),
+		uint16(0),
+		uint32(0),
+		uint64(0),
+		uintptr(0),
+		float32(0),
+		float64(0),
+		bool(false),
+		string(""),
+		[]byte(nil),
+	}
+	for _, v := range fastpathAV {
+		vi = append(vi, reflect.Zero(v.rt).Interface())
+	}
+	for _, v := range vi {
+		rv := reflect.New(reflect.TypeOf(v)).Elem()
+		testRandomFillRV(rv)
+		v = rv.Interface()
+
+		rv2 := reflect.New(rv.Type())
+		rv2.Elem().Set(rv)
+		vp := rv2.Interface()
+
+		var tname string
+		switch rv.Kind() {
+		case reflect.Map:
+			tname = "map[" + rv.Type().Key().Name() + "]" + rv.Type().Elem().Name()
+		case reflect.Slice:
+			tname = "[]" + rv.Type().Elem().Name()
+		default:
+			tname = rv.Type().Name()
+		}
+
+		var b, b1, b2 []byte
+		b1 = testMarshalErr(v, h, t, tname+"-enc")
+		// store b1 into b, as b1 slice is reused for next marshal
+		b = make([]byte, len(b1))
+		copy(b, b1)
+		b2 = testMarshalErr(vp, h, t, tname+"-enc-ptr")
+		testDeepEqualErr(b1, b2, t, tname+"-enc-eq")
+		setZero(vp)
+		testDeepEqualErr(rv2.Elem().Interface(), reflect.Zero(rv.Type()).Interface(), t, tname+"-enc-eq-zero-ref")
+
+		vp = rv2.Interface()
+		testUnmarshalErr(vp, b, h, t, tname+"-dec")
+		testDeepEqualErr(rv2.Elem().Interface(), v, t, tname+"-dec-eq")
+	}
 }
 
 // -----------------
 
+func TestJsonDecodeNonStringScalarInStringContext(t *testing.T) {
+	testOnce.Do(testInitAll)
+	var b = `{"s.true": "true", "b.true": true, "s.false": "false", "b.false": false, "s.10": "10", "i.10": 10, "i.-10": -10}`
+	var golden = map[string]string{"s.true": "true", "b.true": "true", "s.false": "false", "b.false": "false", "s.10": "10", "i.10": "10", "i.-10": "-10"}
+
+	var m map[string]string
+	d := NewDecoderBytes([]byte(b), testJsonH)
+	d.MustDecode(&m)
+	if err := deepEqual(golden, m); err == nil {
+		logT(t, "++++ match: decoded: %#v", m)
+	} else {
+		logT(t, "---- mismatch: %v ==> golden: %#v, decoded: %#v", err, golden, m)
+		failT(t)
+	}
+}
+
+func TestJsonEncodeIndent(t *testing.T) {
+	testOnce.Do(testInitAll)
+	v := TestSimplish{
+		Ii: -794,
+		Ss: `A Man is
+after the new line
+	after new line and tab
+`,
+	}
+	v2 := v
+	v.Mm = make(map[string]*TestSimplish)
+	for i := 0; i < len(v.Ar); i++ {
+		v3 := v2
+		v3.Ii += (i * 4)
+		v3.Ss = fmt.Sprintf("%d - %s", v3.Ii, v3.Ss)
+		if i%2 == 0 {
+			v.Ar[i] = &v3
+		}
+		// v3 = v2
+		v.Sl = append(v.Sl, &v3)
+		v.Mm[strconv.FormatInt(int64(i), 10)] = &v3
+	}
+	oldcan := testJsonH.Canonical
+	oldIndent := testJsonH.Indent
+	oldS2A := testJsonH.StructToArray
+	defer func() {
+		testJsonH.Canonical = oldcan
+		testJsonH.Indent = oldIndent
+		testJsonH.StructToArray = oldS2A
+	}()
+	testJsonH.Canonical = true
+	testJsonH.Indent = -1
+	testJsonH.StructToArray = false
+	var bs []byte
+	NewEncoderBytes(&bs, testJsonH).MustEncode(&v)
+	txt1Tab := string(bs)
+	bs = nil
+	testJsonH.Indent = 120
+	NewEncoderBytes(&bs, testJsonH).MustEncode(&v)
+	txtSpaces := string(bs)
+	// fmt.Printf("\n-----------\n%s\n------------\n%s\n-------------\n", txt1Tab, txtSpaces)
+
+	goldenResultTab := `{
+	"Ar": [
+		{
+			"Ar": [
+				null,
+				null
+			],
+			"Ii": -794,
+			"Mm": null,
+			"Sl": null,
+			"Ss": "-794 - A Man is\nafter the new line\n\tafter new line and tab\n"
+		},
+		null
+	],
+	"Ii": -794,
+	"Mm": {
+		"0": {
+			"Ar": [
+				null,
+				null
+			],
+			"Ii": -794,
+			"Mm": null,
+			"Sl": null,
+			"Ss": "-794 - A Man is\nafter the new line\n\tafter new line and tab\n"
+		},
+		"1": {
+			"Ar": [
+				null,
+				null
+			],
+			"Ii": -790,
+			"Mm": null,
+			"Sl": null,
+			"Ss": "-790 - A Man is\nafter the new line\n\tafter new line and tab\n"
+		}
+	},
+	"Sl": [
+		{
+			"Ar": [
+				null,
+				null
+			],
+			"Ii": -794,
+			"Mm": null,
+			"Sl": null,
+			"Ss": "-794 - A Man is\nafter the new line\n\tafter new line and tab\n"
+		},
+		{
+			"Ar": [
+				null,
+				null
+			],
+			"Ii": -790,
+			"Mm": null,
+			"Sl": null,
+			"Ss": "-790 - A Man is\nafter the new line\n\tafter new line and tab\n"
+		}
+	],
+	"Ss": "A Man is\nafter the new line\n\tafter new line and tab\n"
+}`
+
+	if txt1Tab != goldenResultTab {
+		logT(t, "decoded indented with tabs != expected: \nexpected: %s\nencoded: %s", goldenResultTab, txt1Tab)
+		failT(t)
+	}
+	if txtSpaces != strings.Replace(goldenResultTab, "\t", strings.Repeat(" ", 120), -1) {
+		logT(t, "decoded indented with spaces != expected: \nexpected: %s\nencoded: %s", goldenResultTab, txtSpaces)
+		failT(t)
+	}
+}
+
+func TestBufioDecReader(t *testing.T) {
+	testOnce.Do(testInitAll)
+	// try to read 85 bytes in chunks of 7 at a time.
+	var s = strings.Repeat("01234'56789      ", 5)
+	// fmt.Printf("s: %s\n", s)
+	var r = strings.NewReader(s)
+	var br = &bufioDecReader{r: r, buf: make([]byte, 0, 13)}
+	b, err := ioutil.ReadAll(br)
+	if err != nil {
+		panic(err)
+	}
+	var s2 = string(b)
+	// fmt.Printf("s==s2: %v, len(s): %v, len(b): %v, len(s2): %v\n", s == s2, len(s), len(b), len(s2))
+	if s != s2 {
+		logT(t, "not equal: \ns:  %s\ns2: %s", s, s2)
+		failT(t)
+	}
+	// Now, test search functions for skip, readTo and readUntil
+	// readUntil ', readTo ', skip whitespace. 3 times in a loop, each time compare the token and/or outs
+	// readUntil: see: 56789
+	var out []byte
+	var token byte
+	br = &bufioDecReader{r: strings.NewReader(s), buf: make([]byte, 0, 7)}
+	// println()
+	for _, v2 := range [...]string{
+		`01234'`,
+		`56789      01234'`,
+		`56789      01234'`,
+		`56789      01234'`,
+	} {
+		out = br.readUntil(nil, '\'')
+		testDeepEqualErr(string(out), v2, t, "-")
+		// fmt.Printf("readUntil: out: `%s`\n", out)
+	}
+	br = &bufioDecReader{r: strings.NewReader(s), buf: make([]byte, 0, 7)}
+	// println()
+	for range [4]struct{}{} {
+		out = br.readTo(nil, &jsonNumSet)
+		testDeepEqualErr(string(out), `01234`, t, "-")
+		// fmt.Printf("readTo: out: `%s`\n", out)
+		out = br.readUntil(nil, '\'')
+		testDeepEqualErr(string(out), "'", t, "-")
+		// fmt.Printf("readUntil: out: `%s`\n", out)
+		out = br.readTo(nil, &jsonNumSet)
+		testDeepEqualErr(string(out), `56789`, t, "-")
+		// fmt.Printf("readTo: out: `%s`\n", out)
+		out = br.readUntil(nil, '0')
+		testDeepEqualErr(string(out), `      0`, t, "-")
+		// fmt.Printf("readUntil: out: `%s`\n", out)
+		br.UnreadByte()
+	}
+	br = &bufioDecReader{r: strings.NewReader(s), buf: make([]byte, 0, 7)}
+	// println()
+	for range [4]struct{}{} {
+		out = br.readUntil(nil, ' ')
+		testDeepEqualErr(string(out), `01234'56789 `, t, "-")
+		// fmt.Printf("readUntil: out: |%s|\n", out)
+		token = br.skip(&jsonCharWhitespaceSet)
+		testDeepEqualErr(token, byte('0'), t, "-")
+		// fmt.Printf("skip: token: '%c'\n", token)
+		br.UnreadByte()
+	}
+	// println()
+}
+
+// -----------
+
+func TestJsonLargeInteger(t *testing.T) {
+	testOnce.Do(testInitAll)
+	for _, i := range []uint8{'L', 'A', 0} {
+		for _, j := range []interface{}{
+			int64(1 << 60),
+			-int64(1 << 60),
+			0,
+			1 << 20,
+			-(1 << 20),
+			uint64(1 << 60),
+			uint(0),
+			uint(1 << 20),
+		} {
+			doTestJsonLargeInteger(t, j, i)
+		}
+	}
+}
+
+func TestJsonInvalidUnicode(t *testing.T) {
+	testOnce.Do(testInitAll)
+	var m = map[string]string{
+		`"\udc49\u0430abc"`: "\uFFFDabc",
+		`"\udc49\u0430"`:    "\uFFFD",
+		`"\udc49abc"`:       "\uFFFDabc",
+		`"\udc49"`:          "\uFFFD",
+		`"\udZ49\u0430abc"`: "\uFFFD\u0430abc",
+		`"\udcG9\u0430"`:    "\uFFFD\u0430",
+		`"\uHc49abc"`:       "\uFFFDabc",
+		`"\uKc49"`:          "\uFFFD",
+		// ``: "",
+	}
+	for k, v := range m {
+		// println("k = ", k)
+		var s string
+		testUnmarshalErr(&s, []byte(k), testJsonH, t, "-")
+		if s != v {
+			logT(t, "not equal: %q, %q", v, s)
+			failT(t)
+		}
+	}
+}
+
+// ----------
+
 func TestBincCodecsTable(t *testing.T) {
 	testCodecTableOne(t, testBincH)
 }
@@ -1603,165 +2658,250 @@ func TestBincUnderlyingType(t *testing.T) {
 	testCodecUnderlyingType(t, testBincH)
 }
 
-func TestJsonLargeInteger(t *testing.T) {
-	for _, i := range []uint8{'L', 'A', 0} {
-		for _, j := range []interface{}{
-			int64(1 << 60),
-			-int64(1 << 60),
-			0,
-			1 << 20,
-			-(1 << 20),
-			uint64(1 << 60),
-			uint(0),
-			uint(1 << 20),
-		} {
-			doTestJsonLargeInteger(t, j, i)
-		}
-	}
+func TestJsonSwallowAndZero(t *testing.T) {
+	doTestSwallowAndZero(t, testJsonH)
 }
 
-func TestJsonDecodeNonStringScalarInStringContext(t *testing.T) {
-	var b = `{"s.true": "true", "b.true": true, "s.false": "false", "b.false": false, "s.10": "10", "i.10": 10, "i.-10": -10}`
-	var golden = map[string]string{"s.true": "true", "b.true": "true", "s.false": "false", "b.false": "false", "s.10": "10", "i.10": "10", "i.-10": "-10"}
-
-	var m map[string]string
-	d := NewDecoderBytes([]byte(b), testJsonH)
-	d.MustDecode(&m)
-	if err := deepEqual(golden, m); err == nil {
-		logT(t, "++++ match: decoded: %#v", m)
-	} else {
-		logT(t, "---- mismatch: %v ==> golden: %#v, decoded: %#v", err, golden, m)
-		failT(t)
-	}
+func TestCborSwallowAndZero(t *testing.T) {
+	doTestSwallowAndZero(t, testCborH)
 }
 
-func TestJsonEncodeIndent(t *testing.T) {
-	v := TestSimplish{
-		Ii: -794,
-		Ss: `A Man is
-after the new line
-	after new line and tab
-`,
-	}
-	v2 := v
-	v.Mm = make(map[string]*TestSimplish)
-	for i := 0; i < len(v.Ar); i++ {
-		v3 := v2
-		v3.Ii += (i * 4)
-		v3.Ss = fmt.Sprintf("%d - %s", v3.Ii, v3.Ss)
-		if i%2 == 0 {
-			v.Ar[i] = &v3
-		}
-		// v3 = v2
-		v.Sl = append(v.Sl, &v3)
-		v.Mm[strconv.FormatInt(int64(i), 10)] = &v3
-	}
-	oldcan := testJsonH.Canonical
-	oldIndent := testJsonH.Indent
-	oldS2A := testJsonH.StructToArray
-	defer func() {
-		testJsonH.Canonical = oldcan
-		testJsonH.Indent = oldIndent
-		testJsonH.StructToArray = oldS2A
-	}()
-	testJsonH.Canonical = true
-	testJsonH.Indent = -1
-	testJsonH.StructToArray = false
-	var bs []byte
-	NewEncoderBytes(&bs, testJsonH).MustEncode(&v)
-	txt1Tab := string(bs)
-	bs = nil
-	testJsonH.Indent = 120
-	NewEncoderBytes(&bs, testJsonH).MustEncode(&v)
-	txtSpaces := string(bs)
-	// fmt.Printf("\n-----------\n%s\n------------\n%s\n-------------\n", txt1Tab, txtSpaces)
+func TestMsgpackSwallowAndZero(t *testing.T) {
+	doTestSwallowAndZero(t, testMsgpackH)
+}
 
-	goldenResultTab := `{
-	"Ar": [
-		{
-			"Ar": [
-				null,
-				null
-			],
-			"Ii": -794,
-			"Mm": null,
-			"Sl": null,
-			"Ss": "-794 - A Man is\nafter the new line\n\tafter new line and tab\n"
-		},
-		null
-	],
-	"Ii": -794,
-	"Mm": {
-		"0": {
-			"Ar": [
-				null,
-				null
-			],
-			"Ii": -794,
-			"Mm": null,
-			"Sl": null,
-			"Ss": "-794 - A Man is\nafter the new line\n\tafter new line and tab\n"
-		},
-		"1": {
-			"Ar": [
-				null,
-				null
-			],
-			"Ii": -790,
-			"Mm": null,
-			"Sl": null,
-			"Ss": "-790 - A Man is\nafter the new line\n\tafter new line and tab\n"
-		}
-	},
-	"Sl": [
-		{
-			"Ar": [
-				null,
-				null
-			],
-			"Ii": -794,
-			"Mm": null,
-			"Sl": null,
-			"Ss": "-794 - A Man is\nafter the new line\n\tafter new line and tab\n"
-		},
-		{
-			"Ar": [
-				null,
-				null
-			],
-			"Ii": -790,
-			"Mm": null,
-			"Sl": null,
-			"Ss": "-790 - A Man is\nafter the new line\n\tafter new line and tab\n"
-		}
-	],
-	"Ss": "A Man is\nafter the new line\n\tafter new line and tab\n"
-}`
+func TestBincSwallowAndZero(t *testing.T) {
+	doTestSwallowAndZero(t, testBincH)
+}
 
-	if txt1Tab != goldenResultTab {
-		logT(t, "decoded indented with tabs != expected: \nexpected: %s\nencoded: %s", goldenResultTab, txt1Tab)
-		failT(t)
-	}
-	if txtSpaces != strings.Replace(goldenResultTab, "\t", strings.Repeat(" ", 120), -1) {
-		logT(t, "decoded indented with spaces != expected: \nexpected: %s\nencoded: %s", goldenResultTab, txtSpaces)
-		failT(t)
-	}
+func TestSimpleSwallowAndZero(t *testing.T) {
+	doTestSwallowAndZero(t, testSimpleH)
+}
+
+func TestJsonRawExt(t *testing.T) {
+	doTestRawExt(t, testJsonH)
+}
+
+func TestCborRawExt(t *testing.T) {
+	doTestRawExt(t, testCborH)
+}
+
+func TestMsgpackRawExt(t *testing.T) {
+	doTestRawExt(t, testMsgpackH)
+}
+
+func TestBincRawExt(t *testing.T) {
+	doTestRawExt(t, testBincH)
+}
+
+func TestSimpleRawExt(t *testing.T) {
+	doTestRawExt(t, testSimpleH)
+}
+
+func TestJsonMapStructKey(t *testing.T) {
+	doTestMapStructKey(t, testJsonH)
+}
+
+func TestCborMapStructKey(t *testing.T) {
+	doTestMapStructKey(t, testCborH)
+}
+
+func TestMsgpackMapStructKey(t *testing.T) {
+	doTestMapStructKey(t, testMsgpackH)
+}
+
+func TestBincMapStructKey(t *testing.T) {
+	doTestMapStructKey(t, testBincH)
+}
+
+func TestSimpleMapStructKey(t *testing.T) {
+	doTestMapStructKey(t, testSimpleH)
+}
+
+func TestJsonDecodeNilMapValue(t *testing.T) {
+	doTestDecodeNilMapValue(t, testJsonH)
+}
+
+func TestCborDecodeNilMapValue(t *testing.T) {
+	doTestDecodeNilMapValue(t, testCborH)
+}
+
+func TestMsgpackDecodeNilMapValue(t *testing.T) {
+	doTestDecodeNilMapValue(t, testMsgpackH)
+}
+
+func TestBincDecodeNilMapValue(t *testing.T) {
+	doTestDecodeNilMapValue(t, testBincH)
+}
+
+func TestSimpleDecodeNilMapValue(t *testing.T) {
+	doTestDecodeNilMapValue(t, testSimpleH)
+}
+
+func TestJsonEmbeddedFieldPrecedence(t *testing.T) {
+	doTestEmbeddedFieldPrecedence(t, testJsonH)
+}
+
+func TestCborEmbeddedFieldPrecedence(t *testing.T) {
+	doTestEmbeddedFieldPrecedence(t, testCborH)
+}
+
+func TestMsgpackEmbeddedFieldPrecedence(t *testing.T) {
+	doTestEmbeddedFieldPrecedence(t, testMsgpackH)
+}
+
+func TestBincEmbeddedFieldPrecedence(t *testing.T) {
+	doTestEmbeddedFieldPrecedence(t, testBincH)
+}
+
+func TestSimpleEmbeddedFieldPrecedence(t *testing.T) {
+	doTestEmbeddedFieldPrecedence(t, testSimpleH)
+}
+
+func TestJsonLargeContainerLen(t *testing.T) {
+	doTestLargeContainerLen(t, testJsonH)
+}
+
+func TestCborLargeContainerLen(t *testing.T) {
+	doTestLargeContainerLen(t, testCborH)
+}
+
+func TestMsgpackLargeContainerLen(t *testing.T) {
+	doTestLargeContainerLen(t, testMsgpackH)
+}
+
+func TestBincLargeContainerLen(t *testing.T) {
+	doTestLargeContainerLen(t, testBincH)
+}
+
+func TestSimpleLargeContainerLen(t *testing.T) {
+	doTestLargeContainerLen(t, testSimpleH)
+}
+
+func TestJsonMammothMapsAndSlices(t *testing.T) {
+	doTestMammothMapsAndSlices(t, testJsonH)
+}
+
+func TestCborMammothMapsAndSlices(t *testing.T) {
+	doTestMammothMapsAndSlices(t, testCborH)
+}
+
+func TestMsgpackMammothMapsAndSlices(t *testing.T) {
+	old1, old2 := testMsgpackH.RawToString, testMsgpackH.WriteExt
+	defer func() { testMsgpackH.RawToString, testMsgpackH.WriteExt = old1, old2 }()
+	testMsgpackH.RawToString = true
+	testMsgpackH.WriteExt = true
+
+	doTestMammothMapsAndSlices(t, testMsgpackH)
+}
+
+func TestBincMammothMapsAndSlices(t *testing.T) {
+	doTestMammothMapsAndSlices(t, testBincH)
+}
+
+func TestSimpleMammothMapsAndSlices(t *testing.T) {
+	doTestMammothMapsAndSlices(t, testSimpleH)
+}
+
+func TestJsonTime(t *testing.T) {
+	testTime(t, "json", testJsonH)
+}
+
+func TestCborTime(t *testing.T) {
+	testTime(t, "cbor", testCborH)
+}
+
+func TestMsgpackTime(t *testing.T) {
+	testTime(t, "msgpack", testMsgpackH)
+}
+
+func TestBincTime(t *testing.T) {
+	testTime(t, "binc", testBincH)
+}
+
+func TestSimpleTime(t *testing.T) {
+	testTime(t, "simple", testSimpleH)
+}
+
+func TestJsonUintToInt(t *testing.T) {
+	testUintToInt(t, "json", testJsonH)
+}
+
+func TestCborUintToInt(t *testing.T) {
+	testUintToInt(t, "cbor", testCborH)
+}
+
+func TestMsgpackUintToInt(t *testing.T) {
+	testUintToInt(t, "msgpack", testMsgpackH)
+}
+
+func TestBincUintToInt(t *testing.T) {
+	testUintToInt(t, "binc", testBincH)
+}
+
+func TestSimpleUintToInt(t *testing.T) {
+	testUintToInt(t, "simple", testSimpleH)
+}
+
+func TestJsonDifferentMapOrSliceType(t *testing.T) {
+	doTestDifferentMapOrSliceType(t, "json", testJsonH)
+}
+
+func TestCborDifferentMapOrSliceType(t *testing.T) {
+	doTestDifferentMapOrSliceType(t, "cbor", testCborH)
+}
+
+func TestMsgpackDifferentMapOrSliceType(t *testing.T) {
+	doTestDifferentMapOrSliceType(t, "msgpack", testMsgpackH)
+}
+
+func TestBincDifferentMapOrSliceType(t *testing.T) {
+	doTestDifferentMapOrSliceType(t, "binc", testBincH)
+}
+
+func TestSimpleDifferentMapOrSliceType(t *testing.T) {
+	doTestDifferentMapOrSliceType(t, "simple", testSimpleH)
+}
+
+func TestJsonScalars(t *testing.T) {
+	doTestScalars(t, "json", testJsonH)
+}
+
+func TestCborScalars(t *testing.T) {
+	doTestScalars(t, "cbor", testCborH)
+}
+
+func TestMsgpackScalars(t *testing.T) {
+	doTestScalars(t, "msgpack", testMsgpackH)
+}
+
+func TestBincScalars(t *testing.T) {
+	doTestScalars(t, "binc", testBincH)
+}
+
+func TestSimpleScalars(t *testing.T) {
+	doTestScalars(t, "simple", testSimpleH)
 }
 
 // TODO:
-//   Add Tests for:
-//   - decoding empty list/map in stream into a nil slice/map
-//   - binary(M|Unm)arsher support for time.Time (e.g. cbor encoding)
-//   - text(M|Unm)arshaler support for time.Time (e.g. json encoding)
-//   - non fast-path scenarios e.g. map[string]uint16, []customStruct.
-//     Expand cbor to include indefinite length stuff for this non-fast-path types.
-//     This may not be necessary, since we have the manual tests (fastpathEnabled=false) to test/validate with.
-//   - CodecSelfer
-//     Ensure it is called when (en|de)coding interface{} or reflect.Value (2 different codepaths).
-//   - interfaces: textMarshaler, binaryMarshaler, codecSelfer
-//   - struct tags:
-//     on anonymous fields, _struct (all fields), etc
-//   - codecgen of struct containing channels.
 //
-//  Add negative tests for failure conditions:
-//   - bad input with large array length prefix
+// Add Tests for:
+// - struct tags: on anonymous fields, _struct (all fields), etc
+// - chan to encode and decode (with support for codecgen also)
+//
+// Add negative tests for failure conditions:
+// - bad input with large array length prefix
+//
+// decode.go (standalone)
+// - UnreadByte: only 2 states (z.ls = 2 and z.ls = 1) (0 --> 2 --> 1)
+// - track: z.trb: track, stop track, check
+// - PreferArrayOverSlice???
+// - InterfaceReset
+// - (chan byte) to decode []byte (with mapbyslice track)
+// - decode slice of len 6, 16 into slice of (len 4, cap 8) and (len ) with maxinitlen=6, 8, 16
+// - DeleteOnNilMapValue
+// - decnaked: n.l == nil
+// - ensureDecodeable (try to decode into a non-decodeable thing e.g. a nil interface{},
+//
+// encode.go (standalone)
+// - nil and 0-len slices and maps for non-fastpath things
diff --git a/vendor/github.com/ugorji/go/codec/codecgen/README.md b/vendor/github.com/ugorji/go/codec/codecgen/README.md
deleted file mode 100644
index 854b64bfc..000000000
--- a/vendor/github.com/ugorji/go/codec/codecgen/README.md
+++ /dev/null
@@ -1,37 +0,0 @@
-# codecgen tool
-
-Generate is given a list of *.go files to parse, and an output file (fout),
-codecgen will create an output file __file.go__ which
-contains `codec.Selfer` implementations for the named types found
-in the files parsed.
-
-Using codecgen is very straightforward.
-
-**Download and install the tool**
-
-`go get -u github.com/ugorji/go/codec/codecgen`
-
-**Run the tool on your files**
-
-The command line format is:
-
-`codecgen [options] (-o outfile) (infile ...)`
-
-```sh
-% codecgen -?
-Usage of codecgen:
-  -c="github.com/ugorji/go/codec": codec path
-  -o="": out file
-  -r=".*": regex for type name to match
-  -nr="": regex for type name to exclude
-  -rt="": tags for go run
-  -t="": build tag to put in file
-  -u=false: Use unsafe, e.g. to avoid unnecessary allocation on []byte->string
-  -x=false: keep temp file
-
-% codecgen -o values_codecgen.go values.go values2.go moretypedefs.go
-```
-
-Please see the [blog article](http://ugorji.net/blog/go-codecgen)
-for more information on how to use the tool.
-
diff --git a/vendor/github.com/ugorji/go/codec/codecgen/gen.go b/vendor/github.com/ugorji/go/codec/codecgen/gen.go
index dbde8c3a4..a7bf8f2f3 100644
--- a/vendor/github.com/ugorji/go/codec/codecgen/gen.go
+++ b/vendor/github.com/ugorji/go/codec/codecgen/gen.go
@@ -29,6 +29,8 @@ const genCodecPkg = "codec1978" // keep this in sync with codec.genCodecPkg
 
 const genFrunMainTmpl = `//+build ignore
 
+// Code generated - temporary main package for codecgen - DO NOT EDIT.
+
 package main
 {{ if .Types }}import "{{ .ImportPath }}"{{ end }}
 func main() {
@@ -38,6 +40,9 @@ func main() {
 
 // const genFrunPkgTmpl = `//+build codecgen
 const genFrunPkgTmpl = `
+
+// Code generated - temporary package for codecgen - DO NOT EDIT.
+
 package {{ $.PackageName }}
 
 import (
@@ -62,7 +67,7 @@ func CodecGenTempWrite{{ .RandString }}() {
 	var t{{ $index }} {{ . }}
 	typs = append(typs, reflect.TypeOf(t{{ $index }}))
 {{ end }}
-	{{ if not .CodecPkgFiles }}{{ .CodecPkgName }}.{{ end }}Gen(&out, "{{ .BuildTag }}", "{{ .PackageName }}", "{{ .RandString }}", {{ if not .CodecPkgFiles }}{{ .CodecPkgName }}.{{ end }}NewTypeInfos(strings.Split("{{ .StructTags }}", ",")), typs...)
+	{{ if not .CodecPkgFiles }}{{ .CodecPkgName }}.{{ end }}Gen(&out, "{{ .BuildTag }}", "{{ .PackageName }}", "{{ .RandString }}", {{ .NoExtensions }}, {{ if not .CodecPkgFiles }}{{ .CodecPkgName }}.{{ end }}NewTypeInfos(strings.Split("{{ .StructTags }}", ",")), typs...)
 	bout, err := format.Source(out.Bytes())
 	if err != nil {
 		fout.Write(out.Bytes())
@@ -82,8 +87,12 @@ func CodecGenTempWrite{{ .RandString }}() {
 // Tool then executes: "go run __frun__" which creates fout.
 // fout contains Codec(En|De)codeSelf implementations for every type T.
 //
-func Generate(outfile, buildTag, codecPkgPath string, uid int64, goRunTag string,
-	st string, regexName *regexp.Regexp, notRegexName *regexp.Regexp, deleteTempFile bool, infiles ...string) (err error) {
+func Generate(outfile, buildTag, codecPkgPath string,
+	uid int64,
+	goRunTag string, st string,
+	regexName, notRegexName *regexp.Regexp,
+	deleteTempFile, noExtensions bool,
+	infiles ...string) (err error) {
 	// For each file, grab AST, find each type, and write a call to it.
 	if len(infiles) == 0 {
 		return
@@ -121,6 +130,7 @@ func Generate(outfile, buildTag, codecPkgPath string, uid int64, goRunTag string
 		StructTags      string
 		Types           []string
 		CodecPkgFiles   bool
+		NoExtensions    bool
 	}
 	tv := tmplT{
 		CodecPkgName:    genCodecPkg,
@@ -129,6 +139,7 @@ func Generate(outfile, buildTag, codecPkgPath string, uid int64, goRunTag string
 		BuildTag:        buildTag,
 		RandString:      strconv.FormatInt(uid, 10),
 		StructTags:      st,
+		NoExtensions:    noExtensions,
 	}
 	tv.ImportPath = pkg.ImportPath
 	if tv.ImportPath == tv.CodecImportPath {
@@ -205,6 +216,10 @@ func Generate(outfile, buildTag, codecPkgPath string, uid int64, goRunTag string
 						//   chan: ChanType
 						// do not generate:
 						//   FuncType, InterfaceType, StarExpr (ptr), etc
+						//
+						// We generate for all these types (not just structs), because they may be a field
+						// in another struct which doesn't have codecgen run on it, and it will be nice
+						// to take advantage of the fact that the type is a Selfer.
 						switch td.Type.(type) {
 						case *ast.StructType, *ast.Ident, *ast.MapType, *ast.ArrayType, *ast.ChanType:
 							// only add to tv.Types iff
@@ -311,11 +326,14 @@ func main() {
 	rt := flag.String("rt", "", "tags for go run")
 	st := flag.String("st", "codec,json", "struct tag keys to introspect")
 	x := flag.Bool("x", false, "keep temp file")
-	_ = flag.Bool("u", false, "*IGNORED - kept for backwards compatibility*: Allow unsafe use")
+	_ = flag.Bool("u", false, "Allow unsafe use. ***IGNORED*** - kept for backwards compatibility: ")
 	d := flag.Int64("d", 0, "random identifier for use in generated code")
+	nx := flag.Bool("nx", false, "do not support extensions - support of extensions may cause extra allocation")
+
 	flag.Parse()
-	if err := Generate(*o, *t, *c, *d, *rt, *st,
-		regexp.MustCompile(*r), regexp.MustCompile(*nr), !*x, flag.Args()...); err != nil {
+	err := Generate(*o, *t, *c, *d, *rt, *st,
+		regexp.MustCompile(*r), regexp.MustCompile(*nr), !*x, *nx, flag.Args()...)
+	if err != nil {
 		fmt.Fprintf(os.Stderr, "codecgen error: %v\n", err)
 		os.Exit(1)
 	}
diff --git a/vendor/github.com/ugorji/go/codec/codecgen_test.go b/vendor/github.com/ugorji/go/codec/codecgen_test.go
deleted file mode 100644
index 586af774b..000000000
--- a/vendor/github.com/ugorji/go/codec/codecgen_test.go
+++ /dev/null
@@ -1,24 +0,0 @@
-// +build x,codecgen
-
-package codec
-
-import (
-	"fmt"
-	"testing"
-)
-
-func _TestCodecgenJson1(t *testing.T) {
-	// This is just a simplistic test for codecgen.
-	// It is typically disabled. We only enable it for debugging purposes.
-	const callCodecgenDirect bool = true
-	v := newTestStruc(2, false, !testSkipIntf, false)
-	var bs []byte
-	e := NewEncoderBytes(&bs, testJsonH)
-	if callCodecgenDirect {
-		v.CodecEncodeSelf(e)
-		e.w.atEndOfEncode()
-	} else {
-		e.MustEncode(v)
-	}
-	fmt.Printf("%s\n", bs)
-}
diff --git a/vendor/github.com/ugorji/go/codec/decode.go b/vendor/github.com/ugorji/go/codec/decode.go
index 2cb0b4e3a..2637bad5f 100644
--- a/vendor/github.com/ugorji/go/codec/decode.go
+++ b/vendor/github.com/ugorji/go/codec/decode.go
@@ -9,6 +9,8 @@ import (
 	"fmt"
 	"io"
 	"reflect"
+	"strconv"
+	"sync"
 	"time"
 )
 
@@ -19,8 +21,15 @@ const (
 )
 
 var (
-	onlyMapOrArrayCanDecodeIntoStructErr = errors.New("only encoded map or array can be decoded into a struct")
-	cannotDecodeIntoNilErr               = errors.New("cannot decode into nil")
+	errstrOnlyMapOrArrayCanDecodeIntoStruct = "only encoded map or array can be decoded into a struct"
+	errstrCannotDecodeIntoNil               = "cannot decode into nil"
+
+	errmsgExpandSliceOverflow     = "expand slice: slice overflow"
+	errmsgExpandSliceCannotChange = "expand slice: cannot change"
+
+	errDecUnreadByteNothingToRead   = errors.New("cannot unread - nothing has been read")
+	errDecUnreadByteLastByteNotRead = errors.New("cannot unread - last byte has not been read")
+	errDecUnreadByteUnknown         = errors.New("cannot unread - reason unknown")
 )
 
 // decReader abstracts the reading source, allowing implementations that can
@@ -34,24 +43,18 @@ type decReader interface {
 	readx(n int) []byte
 	readb([]byte)
 	readn1() uint8
-	readn1eof() (v uint8, eof bool)
 	numread() int // number of bytes read
 	track()
 	stopTrack() []byte
 
 	// skip will skip any byte that matches, and return the first non-matching byte
-	skip(accept *[256]bool) (token byte)
+	skip(accept *bitset256) (token byte)
 	// readTo will read any byte that matches, stopping once no-longer matching.
-	readTo(in []byte, accept *[256]bool) (out []byte)
+	readTo(in []byte, accept *bitset256) (out []byte)
 	// readUntil will read, only stopping once it matches the 'stop' byte.
 	readUntil(in []byte, stop byte) (out []byte)
 }
 
-type decReaderByteScanner interface {
-	io.Reader
-	io.ByteScanner
-}
-
 type decDriver interface {
 	// this will check if the next token is a break.
 	CheckBreak() bool
@@ -62,8 +65,7 @@ type decDriver interface {
 	TryDecodeAsNil() bool
 	// vt is one of: Bytes, String, Nil, Slice or Map. Return unSet if not known.
 	ContainerType() (vt valueType)
-	IsBuiltinType(rt uintptr) bool
-	DecodeBuiltin(rt uintptr, v interface{})
+	// IsBuiltinType(rt uintptr) bool
 
 	// DecodeNaked will decode primitives (number, bool, string, []byte) and RawExt.
 	// For maps and arrays, it will not do the decoding in-band, but will signal
@@ -77,9 +79,11 @@ type decDriver interface {
 	// extensions should also use readx to decode them, for efficiency.
 	// kInterface will extract the detached byte slice if it has to pass it outside its realm.
 	DecodeNaked()
+
 	DecodeInt(bitsize uint8) (i int64)
 	DecodeUint(bitsize uint8) (ui uint64)
-	DecodeFloat(chkOverflow32 bool) (f float64)
+
+	DecodeFloat64() (f float64)
 	DecodeBool() (b bool)
 	// DecodeString can also decode symbols.
 	// It looks redundant as DecodeBytes is available.
@@ -97,27 +101,43 @@ type decDriver interface {
 	// decodeExt will decode into a *RawExt or into an extension.
 	DecodeExt(v interface{}, xtag uint64, ext Ext) (realxtag uint64)
 	// decodeExt(verifyTag bool, tag byte) (xtag byte, xbs []byte)
-	ReadMapStart() int
+
+	DecodeTime() (t time.Time)
+
 	ReadArrayStart() int
+	ReadArrayElem()
+	ReadArrayEnd()
+	ReadMapStart() int
+	ReadMapElemKey()
+	ReadMapElemValue()
+	ReadMapEnd()
 
 	reset()
 	uncacheRead()
 }
 
-type decNoSeparator struct {
-}
+type decDriverNoopContainerReader struct{}
 
-func (_ decNoSeparator) ReadEnd() {}
+func (x decDriverNoopContainerReader) ReadArrayStart() (v int) { return }
+func (x decDriverNoopContainerReader) ReadArrayElem()          {}
+func (x decDriverNoopContainerReader) ReadArrayEnd()           {}
+func (x decDriverNoopContainerReader) ReadMapStart() (v int)   { return }
+func (x decDriverNoopContainerReader) ReadMapElemKey()         {}
+func (x decDriverNoopContainerReader) ReadMapElemValue()       {}
+func (x decDriverNoopContainerReader) ReadMapEnd()             {}
+func (x decDriverNoopContainerReader) CheckBreak() (v bool)    { return }
 
-// func (_ decNoSeparator) uncacheRead() {}
+// func (x decNoSeparator) uncacheRead() {}
 
+// DecodeOptions captures configuration options during decode.
 type DecodeOptions struct {
 	// MapType specifies type to use during schema-less decoding of a map in the stream.
-	// If nil, we use map[interface{}]interface{}
+	// If nil (unset), we default to map[string]interface{} iff json handle and MapStringAsKey=true,
+	// else map[interface{}]interface{}.
 	MapType reflect.Type
 
 	// SliceType specifies type to use during schema-less decoding of an array in the stream.
-	// If nil, we use []interface{}
+	// If nil (unset), we default to []interface{} for all formats.
 	SliceType reflect.Type
 
 	// MaxInitLen defines the maxinum initial length that we "make" a collection (string, slice, map, chan).
@@ -154,6 +174,11 @@ type DecodeOptions struct {
 	// or is an interface.
 	MapValueReset bool
 
+	// SliceElementReset: on decoding a slice, reset the element to a zero value first.
+	//
+	// concern: if the slice already contained some garbage, we will decode into that garbage.
+	SliceElementReset bool
+
 	// InterfaceReset controls how we decode into an interface.
 	//
 	// By default, when we see a field that is an interface{...},
@@ -187,20 +212,362 @@ type DecodeOptions struct {
 	// *Note*: This only applies if using go1.5 and above,
 	// as it requires reflect.ArrayOf support which was absent before go1.5.
 	PreferArrayOverSlice bool
+
+	// DeleteOnNilMapValue controls how to decode a nil value in the stream.
+	//
+	// If true, we will delete the mapping of the key.
+	// Else, just set the mapping to the zero value of the type.
+	DeleteOnNilMapValue bool
+
+	// ReaderBufferSize is the size of the buffer used when reading.
+	//
+	// if > 0, we use a smart buffer internally for performance purposes.
+	ReaderBufferSize int
 }
 
 // ------------------------------------
 
-// ioDecByteScanner implements Read(), ReadByte(...), UnreadByte(...) methods
-// of io.Reader, io.ByteScanner.
-type ioDecByteScanner struct {
-	r  io.Reader
-	l  byte    // last byte
-	ls byte    // last byte status. 0: init-canDoNothing, 1: canRead, 2: canUnread
-	b  [1]byte // tiny buffer for reading single bytes
+type bufioDecReader struct {
+	buf []byte
+	r   io.Reader
+
+	c   int // cursor
+	n   int // num read
+	err error
+
+	trb bool
+	tr  []byte
+
+	b [8]byte
 }
 
-func (z *ioDecByteScanner) Read(p []byte) (n int, err error) {
+func (z *bufioDecReader) reset(r io.Reader) {
+	z.r, z.c, z.n, z.err, z.trb = r, 0, 0, nil, false
+	if z.tr != nil {
+		z.tr = z.tr[:0]
+	}
+}
+
+func (z *bufioDecReader) Read(p []byte) (n int, err error) {
+	if z.err != nil {
+		return 0, z.err
+	}
+	p0 := p
+	n = copy(p, z.buf[z.c:])
+	z.c += n
+	if z.c == len(z.buf) {
+		z.c = 0
+	}
+	z.n += n
+	if len(p) == n {
+		if z.c == 0 {
+			z.buf = z.buf[:1]
+			z.buf[0] = p[len(p)-1]
+			z.c = 1
+		}
+		if z.trb {
+			z.tr = append(z.tr, p0[:n]...)
+		}
+		return
+	}
+	p = p[n:]
+	var n2 int
+	// if we are here, then z.buf is all read
+	if len(p) > len(z.buf) {
+		n2, err = decReadFull(z.r, p)
+		n += n2
+		z.n += n2
+		z.err = err
+		// don't return EOF if some bytes were read. keep for next time.
+		if n > 0 && err == io.EOF {
+			err = nil
+		}
+		// always keep last byte in z.buf
+		z.buf = z.buf[:1]
+		z.buf[0] = p[len(p)-1]
+		z.c = 1
+		if z.trb {
+			z.tr = append(z.tr, p0[:n]...)
+		}
+		return
+	}
+	// z.c is now 0, and len(p) <= len(z.buf)
+	for len(p) > 0 && z.err == nil {
+		// println("len(p) loop starting ... ")
+		z.c = 0
+		z.buf = z.buf[0:cap(z.buf)]
+		n2, err = z.r.Read(z.buf)
+		if n2 > 0 {
+			if err == io.EOF {
+				err = nil
+			}
+			z.buf = z.buf[:n2]
+			n2 = copy(p, z.buf)
+			z.c = n2
+			n += n2
+			z.n += n2
+			p = p[n2:]
+		}
+		z.err = err
+		// println("... len(p) loop done")
+	}
+	if z.c == 0 {
+		z.buf = z.buf[:1]
+		z.buf[0] = p[len(p)-1]
+		z.c = 1
+	}
+	if z.trb {
+		z.tr = append(z.tr, p0[:n]...)
+	}
+	return
+}
+
+func (z *bufioDecReader) ReadByte() (b byte, err error) {
+	z.b[0] = 0
+	_, err = z.Read(z.b[:1])
+	b = z.b[0]
+	return
+}
+
+func (z *bufioDecReader) UnreadByte() (err error) {
+	if z.err != nil {
+		return z.err
+	}
+	if z.c > 0 {
+		z.c--
+		z.n--
+		if z.trb {
+			z.tr = z.tr[:len(z.tr)-1]
+		}
+		return
+	}
+	return errDecUnreadByteNothingToRead
+}
+
+func (z *bufioDecReader) numread() int {
+	return z.n
+}
+
+func (z *bufioDecReader) readx(n int) (bs []byte) {
+	if n <= 0 || z.err != nil {
+		return
+	}
+	if z.c+n <= len(z.buf) {
+		bs = z.buf[z.c : z.c+n]
+		z.n += n
+		z.c += n
+		if z.trb {
+			z.tr = append(z.tr, bs...)
+		}
+		return
+	}
+	bs = make([]byte, n)
+	_, err := z.Read(bs)
+	if err != nil {
+		panic(err)
+	}
+	return
+}
+
+func (z *bufioDecReader) readb(bs []byte) {
+	_, err := z.Read(bs)
+	if err != nil {
+		panic(err)
+	}
+}
+
+// func (z *bufioDecReader) readn1eof() (b uint8, eof bool) {
+// 	b, err := z.ReadByte()
+// 	if err != nil {
+// 		if err == io.EOF {
+// 			eof = true
+// 		} else {
+// 			panic(err)
+// 		}
+// 	}
+// 	return
+// }
+
+func (z *bufioDecReader) readn1() (b uint8) {
+	b, err := z.ReadByte()
+	if err != nil {
+		panic(err)
+	}
+	return
+}
+
+func (z *bufioDecReader) search(in []byte, accept *bitset256, stop, flag uint8) (token byte, out []byte) {
+	// flag: 1 (skip), 2 (readTo), 4 (readUntil)
+	if flag == 4 {
+		for i := z.c; i < len(z.buf); i++ {
+			if z.buf[i] == stop {
+				token = z.buf[i]
+				z.n = z.n + (i - z.c) - 1
+				i++
+				out = z.buf[z.c:i]
+				if z.trb {
+					z.tr = append(z.tr, z.buf[z.c:i]...)
+				}
+				z.c = i
+				return
+			}
+		}
+	} else {
+		for i := z.c; i < len(z.buf); i++ {
+			if !accept.isset(z.buf[i]) {
+				token = z.buf[i]
+				z.n = z.n + (i - z.c) - 1
+				if flag == 1 {
+					i++
+				} else {
+					out = z.buf[z.c:i]
+				}
+				if z.trb {
+					z.tr = append(z.tr, z.buf[z.c:i]...)
+				}
+				z.c = i
+				return
+			}
+		}
+	}
+	z.n += len(z.buf) - z.c
+	if flag != 1 {
+		out = append(in, z.buf[z.c:]...)
+	}
+	if z.trb {
+		z.tr = append(z.tr, z.buf[z.c:]...)
+	}
+	var n2 int
+	if z.err != nil {
+		return
+	}
+	for {
+		z.c = 0
+		z.buf = z.buf[0:cap(z.buf)]
+		n2, z.err = z.r.Read(z.buf)
+		if n2 > 0 && z.err != nil {
+			z.err = nil
+		}
+		z.buf = z.buf[:n2]
+		if flag == 4 {
+			for i := 0; i < n2; i++ {
+				if z.buf[i] == stop {
+					token = z.buf[i]
+					z.n += i - 1
+					i++
+					out = append(out, z.buf[z.c:i]...)
+					if z.trb {
+						z.tr = append(z.tr, z.buf[z.c:i]...)
+					}
+					z.c = i
+					return
+				}
+			}
+		} else {
+			for i := 0; i < n2; i++ {
+				if !accept.isset(z.buf[i]) {
+					token = z.buf[i]
+					z.n += i - 1
+					if flag == 1 {
+						i++
+					}
+					if flag != 1 {
+						out = append(out, z.buf[z.c:i]...)
+					}
+					if z.trb {
+						z.tr = append(z.tr, z.buf[z.c:i]...)
+					}
+					z.c = i
+					return
+				}
+			}
+		}
+		if flag != 1 {
+			out = append(out, z.buf[:n2]...)
+		}
+		z.n += n2
+		if z.err != nil {
+			return
+		}
+		if z.trb {
+			z.tr = append(z.tr, z.buf[:n2]...)
+		}
+	}
+}
+
+func (z *bufioDecReader) skip(accept *bitset256) (token byte) {
+	token, _ = z.search(nil, accept, 0, 1)
+	return
+}
+
+func (z *bufioDecReader) readTo(in []byte, accept *bitset256) (out []byte) {
+	_, out = z.search(in, accept, 0, 2)
+	return
+}
+
+func (z *bufioDecReader) readUntil(in []byte, stop byte) (out []byte) {
+	_, out = z.search(in, nil, stop, 4)
+	return
+}
+
+func (z *bufioDecReader) unreadn1() {
+	err := z.UnreadByte()
+	if err != nil {
+		panic(err)
+	}
+}
+
+func (z *bufioDecReader) track() {
+	if z.tr != nil {
+		z.tr = z.tr[:0]
+	}
+	z.trb = true
+}
+
+func (z *bufioDecReader) stopTrack() (bs []byte) {
+	z.trb = false
+	return z.tr
+}
+
+// ioDecReader is a decReader that reads off an io.Reader.
+//
+// It also has a fallback implementation of ByteScanner if needed.
+type ioDecReader struct {
+	r io.Reader // the reader passed in
+
+	rr io.Reader
+	br io.ByteScanner
+
+	l   byte    // last byte
+	ls  byte    // last byte status. 0: init-canDoNothing, 1: canRead, 2: canUnread
+	b   [4]byte // tiny buffer for reading single bytes
+	trb bool    // tracking bytes turned on
+
+	// temp byte array re-used internally for efficiency during read.
+	// shares buffer with Decoder, so we keep size of struct within 8 words.
+	x  *[scratchByteArrayLen]byte
+	n  int    // num read
+	tr []byte // tracking bytes read
+}
+
+func (z *ioDecReader) reset(r io.Reader) {
+	z.r = r
+	z.rr = r
+	z.l, z.ls, z.n, z.trb = 0, 0, 0, false
+	if z.tr != nil {
+		z.tr = z.tr[:0]
+	}
+	var ok bool
+	if z.br, ok = r.(io.ByteScanner); !ok {
+		z.br = z
+		z.rr = z
+	}
+}
+
+func (z *ioDecReader) Read(p []byte) (n int, err error) {
+	if len(p) == 0 {
+		return
+	}
 	var firstByte bool
 	if z.ls == 1 {
 		z.ls = 2
@@ -226,8 +593,8 @@ func (z *ioDecByteScanner) Read(p []byte) (n int, err error) {
 	return
 }
 
-func (z *ioDecByteScanner) ReadByte() (c byte, err error) {
-	n, err := z.Read(z.b[:])
+func (z *ioDecReader) ReadByte() (c byte, err error) {
+	n, err := z.Read(z.b[:1])
 	if n == 1 {
 		c = z.b[0]
 		if err == io.EOF {
@@ -237,30 +604,20 @@ func (z *ioDecByteScanner) ReadByte() (c byte, err error) {
 	return
 }
 
-func (z *ioDecByteScanner) UnreadByte() (err error) {
-	x := z.ls
-	if x == 0 {
-		err = errors.New("cannot unread - nothing has been read")
-	} else if x == 1 {
-		err = errors.New("cannot unread - last byte has not been read")
-	} else if x == 2 {
+func (z *ioDecReader) UnreadByte() (err error) {
+	switch z.ls {
+	case 2:
 		z.ls = 1
+	case 0:
+		err = errDecUnreadByteNothingToRead
+	case 1:
+		err = errDecUnreadByteLastByteNotRead
+	default:
+		err = errDecUnreadByteUnknown
 	}
 	return
 }
 
-// ioDecReader is a decReader that reads off an io.Reader
-type ioDecReader struct {
-	br decReaderByteScanner
-	// temp byte array re-used internally for efficiency during read.
-	// shares buffer with Decoder, so we keep size of struct within 8 words.
-	x   *[scratchByteArrayLen]byte
-	bs  ioDecByteScanner
-	n   int    // num read
-	tr  []byte // tracking bytes read
-	trb bool
-}
-
 func (z *ioDecReader) numread() int {
 	return z.n
 }
@@ -274,7 +631,7 @@ func (z *ioDecReader) readx(n int) (bs []byte) {
 	} else {
 		bs = make([]byte, n)
 	}
-	if _, err := io.ReadAtLeast(z.br, bs, n); err != nil {
+	if _, err := decReadFull(z.rr, bs); err != nil {
 		panic(err)
 	}
 	z.n += len(bs)
@@ -285,31 +642,18 @@ func (z *ioDecReader) readx(n int) (bs []byte) {
 }
 
 func (z *ioDecReader) readb(bs []byte) {
-	if len(bs) == 0 {
-		return
-	}
-	n, err := io.ReadAtLeast(z.br, bs, len(bs))
-	z.n += n
-	if err != nil {
+	// if len(bs) == 0 {
+	// 	return
+	// }
+	if _, err := decReadFull(z.rr, bs); err != nil {
 		panic(err)
 	}
+	z.n += len(bs)
 	if z.trb {
 		z.tr = append(z.tr, bs...)
 	}
 }
 
-func (z *ioDecReader) readn1() (b uint8) {
-	b, err := z.br.ReadByte()
-	if err != nil {
-		panic(err)
-	}
-	z.n++
-	if z.trb {
-		z.tr = append(z.tr, b)
-	}
-	return b
-}
-
 func (z *ioDecReader) readn1eof() (b uint8, eof bool) {
 	b, err := z.br.ReadByte()
 	if err == nil {
@@ -325,28 +669,40 @@ func (z *ioDecReader) readn1eof() (b uint8, eof bool) {
 	return
 }
 
-func (z *ioDecReader) skip(accept *[256]bool) (token byte) {
+func (z *ioDecReader) readn1() (b uint8) {
+	var err error
+	if b, err = z.br.ReadByte(); err == nil {
+		z.n++
+		if z.trb {
+			z.tr = append(z.tr, b)
+		}
+		return
+	}
+	panic(err)
+}
+
+func (z *ioDecReader) skip(accept *bitset256) (token byte) {
 	for {
 		var eof bool
 		token, eof = z.readn1eof()
 		if eof {
 			return
 		}
-		if accept[token] {
+		if accept.isset(token) {
 			continue
 		}
 		return
 	}
 }
 
-func (z *ioDecReader) readTo(in []byte, accept *[256]bool) (out []byte) {
+func (z *ioDecReader) readTo(in []byte, accept *bitset256) (out []byte) {
 	out = in
 	for {
 		token, eof := z.readn1eof()
 		if eof {
 			return
 		}
-		if accept[token] {
+		if accept.isset(token) {
 			out = append(out, token)
 		} else {
 			z.unreadn1()
@@ -396,7 +752,7 @@ func (z *ioDecReader) stopTrack() (bs []byte) {
 
 // ------------------------------------
 
-var bytesDecReaderCannotUnreadErr = errors.New("cannot unread last byte read")
+var errBytesDecReaderCannotUnread = errors.New("cannot unread last byte read")
 
 // bytesDecReader is a decReader that reads off a byte slice with zero copying
 type bytesDecReader struct {
@@ -419,7 +775,7 @@ func (z *bytesDecReader) numread() int {
 
 func (z *bytesDecReader) unreadn1() {
 	if z.c == 0 || len(z.b) == 0 {
-		panic(bytesDecReaderCannotUnreadErr)
+		panic(errBytesDecReaderCannotUnread)
 	}
 	z.c--
 	z.a++
@@ -459,64 +815,60 @@ func (z *bytesDecReader) readn1() (v uint8) {
 	return
 }
 
-func (z *bytesDecReader) readn1eof() (v uint8, eof bool) {
-	if z.a == 0 {
-		eof = true
-		return
-	}
-	v = z.b[z.c]
-	z.c++
-	z.a--
-	return
-}
+// func (z *bytesDecReader) readn1eof() (v uint8, eof bool) {
+// 	if z.a == 0 {
+// 		eof = true
+// 		return
+// 	}
+// 	v = z.b[z.c]
+// 	z.c++
+// 	z.a--
+// 	return
+// }
 
-func (z *bytesDecReader) skip(accept *[256]bool) (token byte) {
+func (z *bytesDecReader) skip(accept *bitset256) (token byte) {
 	if z.a == 0 {
 		return
 	}
-	for i := z.c; i < len(z.b); i++ {
-		// fmt.Printf(">>>> skipWhitespace: checking: index: %d, %s\n", i, string(z.b[i]))
-		if accept[z.b[i]] {
-			continue
+	blen := len(z.b)
+	for i := z.c; i < blen; i++ {
+		if !accept.isset(z.b[i]) {
+			token = z.b[i]
+			i++
+			z.a -= (i - z.c)
+			z.c = i
+			return
 		}
-		// fmt.Printf(">>>> skipWhitespace: returning\n")
-		token = z.b[i]
-		i++
-		z.a -= (i - z.c)
-		z.c = i
-		return
 	}
-	z.a, z.c = 0, len(z.b)
+	z.a, z.c = 0, blen
 	return
 }
 
-func (z *bytesDecReader) readTo(in []byte, accept *[256]bool) (out []byte) {
+func (z *bytesDecReader) readTo(_ []byte, accept *bitset256) (out []byte) {
 	if z.a == 0 {
 		return
 	}
-	for i := z.c; i < len(z.b); i++ {
-		// fmt.Printf(">>>> readbUntilAny: checking: index: %d, %s\n", i, string(z.b[i]))
-		if !accept[z.b[i]] {
+	blen := len(z.b)
+	for i := z.c; i < blen; i++ {
+		if !accept.isset(z.b[i]) {
 			out = z.b[z.c:i]
-			// fmt.Printf(">>>> readbUntilAny: returning: %s\n", z.b[z.c:i])
 			z.a -= (i - z.c)
 			z.c = i
 			return
 		}
 	}
 	out = z.b[z.c:]
-	z.a, z.c = 0, len(z.b)
+	z.a, z.c = 0, blen
 	return
 }
 
-func (z *bytesDecReader) readUntil(in []byte, stop byte) (out []byte) {
+func (z *bytesDecReader) readUntil(_ []byte, stop byte) (out []byte) {
 	if z.a == 0 {
 		panic(io.EOF)
 	}
-	for i := z.c; i < len(z.b); i++ {
-		// fmt.Printf(">>>> readbUntilDblQUote: checking: index: %d, %s\n", i, string(z.b[i]))
+	blen := len(z.b)
+	for i := z.c; i < blen; i++ {
 		if z.b[i] == stop {
-			// fmt.Printf(">>>> readbUntilDblQUote: returning\n")
 			i++
 			out = z.b[z.c:i]
 			z.a -= (i - z.c)
@@ -524,7 +876,7 @@ func (z *bytesDecReader) readUntil(in []byte, stop byte) (out []byte) {
 			return
 		}
 	}
-	z.a, z.c = 0, len(z.b)
+	z.a, z.c = 0, blen
 	panic(io.EOF)
 }
 
@@ -536,103 +888,62 @@ func (z *bytesDecReader) stopTrack() (bs []byte) {
 	return z.b[z.t:z.c]
 }
 
-// ------------------------------------
-
-type decFnInfo struct {
-	d     *Decoder
-	ti    *typeInfo
-	xfFn  Ext
-	xfTag uint64
-	seq   seqType
-}
-
 // ----------------------------------------
 
-type decFn struct {
-	i decFnInfo
-	f func(*decFnInfo, reflect.Value)
+// func (d *Decoder) builtin(f *codecFnInfo, rv reflect.Value) {
+// 	d.d.DecodeBuiltin(f.ti.rtid, rv2i(rv))
+// }
+
+func (d *Decoder) rawExt(f *codecFnInfo, rv reflect.Value) {
+	d.d.DecodeExt(rv2i(rv), 0, nil)
 }
 
-func (f *decFnInfo) builtin(rv reflect.Value) {
-	f.d.d.DecodeBuiltin(f.ti.rtid, rv2i(rv.Addr()))
+func (d *Decoder) ext(f *codecFnInfo, rv reflect.Value) {
+	d.d.DecodeExt(rv2i(rv), f.xfTag, f.xfFn)
 }
 
-func (f *decFnInfo) rawExt(rv reflect.Value) {
-	f.d.d.DecodeExt(rv2i(rv.Addr()), 0, nil)
+func (d *Decoder) selferUnmarshal(f *codecFnInfo, rv reflect.Value) {
+	rv2i(rv).(Selfer).CodecDecodeSelf(d)
 }
 
-func (f *decFnInfo) ext(rv reflect.Value) {
-	f.d.d.DecodeExt(rv2i(rv.Addr()), f.xfTag, f.xfFn)
-}
-
-func (f *decFnInfo) getValueForUnmarshalInterface(rv reflect.Value, indir int8) (v interface{}) {
-	if indir == -1 {
-		v = rv2i(rv.Addr())
-	} else if indir == 0 {
-		v = rv2i(rv)
-	} else {
-		for j := int8(0); j < indir; j++ {
-			if rv.IsNil() {
-				rv.Set(reflect.New(rv.Type().Elem()))
-			}
-			rv = rv.Elem()
-		}
-		v = rv2i(rv)
-	}
-	return
-}
-
-func (f *decFnInfo) selferUnmarshal(rv reflect.Value) {
-	f.getValueForUnmarshalInterface(rv, f.ti.csIndir).(Selfer).CodecDecodeSelf(f.d)
-}
-
-func (f *decFnInfo) binaryUnmarshal(rv reflect.Value) {
-	bm := f.getValueForUnmarshalInterface(rv, f.ti.bunmIndir).(encoding.BinaryUnmarshaler)
-	xbs := f.d.d.DecodeBytes(nil, true)
+func (d *Decoder) binaryUnmarshal(f *codecFnInfo, rv reflect.Value) {
+	bm := rv2i(rv).(encoding.BinaryUnmarshaler)
+	xbs := d.d.DecodeBytes(nil, true)
 	if fnerr := bm.UnmarshalBinary(xbs); fnerr != nil {
 		panic(fnerr)
 	}
 }
 
-func (f *decFnInfo) textUnmarshal(rv reflect.Value) {
-	tm := f.getValueForUnmarshalInterface(rv, f.ti.tunmIndir).(encoding.TextUnmarshaler)
-	fnerr := tm.UnmarshalText(f.d.d.DecodeStringAsBytes())
+func (d *Decoder) textUnmarshal(f *codecFnInfo, rv reflect.Value) {
+	tm := rv2i(rv).(encoding.TextUnmarshaler)
+	fnerr := tm.UnmarshalText(d.d.DecodeStringAsBytes())
 	if fnerr != nil {
 		panic(fnerr)
 	}
 }
 
-func (f *decFnInfo) jsonUnmarshal(rv reflect.Value) {
-	tm := f.getValueForUnmarshalInterface(rv, f.ti.junmIndir).(jsonUnmarshaler)
-	// bs := f.d.d.DecodeBytes(f.d.b[:], true, true)
+func (d *Decoder) jsonUnmarshal(f *codecFnInfo, rv reflect.Value) {
+	tm := rv2i(rv).(jsonUnmarshaler)
+	// bs := d.d.DecodeBytes(d.b[:], true, true)
 	// grab the bytes to be read, as UnmarshalJSON needs the full JSON so as to unmarshal it itself.
-	fnerr := tm.UnmarshalJSON(f.d.nextValueBytes())
+	fnerr := tm.UnmarshalJSON(d.nextValueBytes())
 	if fnerr != nil {
 		panic(fnerr)
 	}
 }
 
-func (f *decFnInfo) kErr(rv reflect.Value) {
-	f.d.errorf("no decoding function defined for kind %v", rv.Kind())
+func (d *Decoder) kErr(f *codecFnInfo, rv reflect.Value) {
+	d.errorf("no decoding function defined for kind %v", rv.Kind())
 }
 
-// func (f *decFnInfo) kPtr(rv reflect.Value) {
-// 	debugf(">>>>>>> ??? decode kPtr called - shouldn't get called")
-// 	if rv.IsNil() {
-// 		rv.Set(reflect.New(rv.Type().Elem()))
-// 	}
-// 	f.d.decodeValue(rv.Elem())
-// }
-
 // var kIntfCtr uint64
 
-func (f *decFnInfo) kInterfaceNaked() (rvn reflect.Value) {
+func (d *Decoder) kInterfaceNaked(f *codecFnInfo) (rvn reflect.Value) {
 	// nil interface:
 	// use some hieristics to decode it appropriately
 	// based on the detected next value in the stream.
-	d := f.d
+	n := d.naked()
 	d.d.DecodeNaked()
-	n := &d.n
 	if n.v == valueTypeNil {
 		return
 	}
@@ -645,183 +956,237 @@ func (f *decFnInfo) kInterfaceNaked() (rvn reflect.Value) {
 	// var useRvn bool
 	switch n.v {
 	case valueTypeMap:
-		// if d.h.MapType == nil || d.h.MapType == mapIntfIntfTyp {
-		// } else if d.h.MapType == mapStrIntfTyp { // for json performance
-		// }
-		if d.mtid == 0 || d.mtid == mapIntfIntfTypId {
-			l := len(n.ms)
-			n.ms = append(n.ms, nil)
-			var v2 interface{} = &n.ms[l]
-			d.decode(v2)
-			rvn = d.np.get(v2)
-			n.ms = n.ms[:l]
-		} else if d.mtid == mapStrIntfTypId { // for json performance
-			l := len(n.ns)
-			n.ns = append(n.ns, nil)
-			var v2 interface{} = &n.ns[l]
-			d.decode(v2)
-			rvn = d.np.get(v2)
-			n.ns = n.ns[:l]
-		} else {
-			rvn = reflect.New(d.h.MapType).Elem()
-			d.decodeValue(rvn, nil)
-		}
-	case valueTypeArray:
-		// if d.h.SliceType == nil || d.h.SliceType == intfSliceTyp {
-		if d.stid == 0 || d.stid == intfSliceTypId {
-			l := len(n.ss)
-			n.ss = append(n.ss, nil)
-			var v2 interface{} = &n.ss[l]
-			d.decode(v2)
-			n.ss = n.ss[:l]
-			if reflectArrayOfSupported && d.stid == 0 && d.h.PreferArrayOverSlice {
-				rvn00 := d.np.get(v2)
-				rvn = reflect.New(reflectArrayOf(rvn00.Len(), intfTyp)).Elem()
-				reflect.Copy(rvn, rvn00)
+		// if json, default to a map type with string keys
+		mtid := d.mtid
+		if mtid == 0 {
+			if d.jsms {
+				mtid = mapStrIntfTypId
 			} else {
-				rvn = d.np.get(v2)
+				mtid = mapIntfIntfTypId
+			}
+		}
+		if mtid == mapIntfIntfTypId {
+			if n.lm < arrayCacheLen {
+				n.ma[n.lm] = nil
+				rvn = n.rr[decNakedMapIntfIntfIdx*arrayCacheLen+n.lm]
+				n.lm++
+				d.decode(&n.ma[n.lm-1])
+				n.lm--
+			} else {
+				var v2 map[interface{}]interface{}
+				d.decode(&v2)
+				rvn = reflect.ValueOf(&v2).Elem()
+			}
+		} else if mtid == mapStrIntfTypId { // for json performance
+			if n.ln < arrayCacheLen {
+				n.na[n.ln] = nil
+				rvn = n.rr[decNakedMapStrIntfIdx*arrayCacheLen+n.ln]
+				n.ln++
+				d.decode(&n.na[n.ln-1])
+				n.ln--
+			} else {
+				var v2 map[string]interface{}
+				d.decode(&v2)
+				rvn = reflect.ValueOf(&v2).Elem()
 			}
 		} else {
-			rvn = reflect.New(d.h.SliceType).Elem()
-			d.decodeValue(rvn, nil)
+			if d.mtr {
+				rvn = reflect.New(d.h.MapType)
+				d.decode(rv2i(rvn))
+				rvn = rvn.Elem()
+			} else {
+				rvn = reflect.New(d.h.MapType).Elem()
+				d.decodeValue(rvn, nil, true)
+			}
+		}
+	case valueTypeArray:
+		if d.stid == 0 || d.stid == intfSliceTypId {
+			if n.ls < arrayCacheLen {
+				n.sa[n.ls] = nil
+				rvn = n.rr[decNakedSliceIntfIdx*arrayCacheLen+n.ls]
+				n.ls++
+				d.decode(&n.sa[n.ls-1])
+				n.ls--
+			} else {
+				var v2 []interface{}
+				d.decode(&v2)
+				rvn = reflect.ValueOf(&v2).Elem()
+			}
+			if reflectArrayOfSupported && d.stid == 0 && d.h.PreferArrayOverSlice {
+				rvn2 := reflect.New(reflectArrayOf(rvn.Len(), intfTyp)).Elem()
+				reflect.Copy(rvn2, rvn)
+				rvn = rvn2
+			}
+		} else {
+			if d.str {
+				rvn = reflect.New(d.h.SliceType)
+				d.decode(rv2i(rvn))
+				rvn = rvn.Elem()
+			} else {
+				rvn = reflect.New(d.h.SliceType).Elem()
+				d.decodeValue(rvn, nil, true)
+			}
 		}
 	case valueTypeExt:
 		var v interface{}
 		tag, bytes := n.u, n.l // calling decode below might taint the values
 		if bytes == nil {
-			l := len(n.is)
-			n.is = append(n.is, nil)
-			v2 := &n.is[l]
-			d.decode(v2)
-			v = *v2
-			n.is = n.is[:l]
+			if n.li < arrayCacheLen {
+				n.ia[n.li] = nil
+				n.li++
+				d.decode(&n.ia[n.li-1])
+				// v = *(&n.ia[l])
+				n.li--
+				v = n.ia[n.li]
+				n.ia[n.li] = nil
+			} else {
+				d.decode(&v)
+			}
 		}
 		bfn := d.h.getExtForTag(tag)
 		if bfn == nil {
 			var re RawExt
 			re.Tag = tag
 			re.Data = detachZeroCopyBytes(d.bytes, nil, bytes)
-			rvn = reflect.ValueOf(re)
+			re.Value = v
+			rvn = reflect.ValueOf(&re).Elem()
 		} else {
 			rvnA := reflect.New(bfn.rt)
-			rvn = rvnA.Elem()
 			if bytes != nil {
 				bfn.ext.ReadExt(rv2i(rvnA), bytes)
 			} else {
 				bfn.ext.UpdateExt(rv2i(rvnA), v)
 			}
+			rvn = rvnA.Elem()
 		}
 	case valueTypeNil:
 		// no-op
 	case valueTypeInt:
-		rvn = d.np.get(&n.i)
+		rvn = n.rr[decNakedIntIdx] // d.np.get(&n.i)
 	case valueTypeUint:
-		rvn = d.np.get(&n.u)
+		rvn = n.rr[decNakedUintIdx] // d.np.get(&n.u)
 	case valueTypeFloat:
-		rvn = d.np.get(&n.f)
+		rvn = n.rr[decNakedFloatIdx] // d.np.get(&n.f)
 	case valueTypeBool:
-		rvn = d.np.get(&n.b)
+		rvn = n.rr[decNakedBoolIdx] // d.np.get(&n.b)
 	case valueTypeString, valueTypeSymbol:
-		rvn = d.np.get(&n.s)
+		rvn = n.rr[decNakedStringIdx] // d.np.get(&n.s)
 	case valueTypeBytes:
-		rvn = d.np.get(&n.l)
-	case valueTypeTimestamp:
-		rvn = d.np.get(&n.t)
+		rvn = n.rr[decNakedBytesIdx] // d.np.get(&n.l)
+	case valueTypeTime:
+		rvn = n.rr[decNakedTimeIdx] // d.np.get(&n.t)
 	default:
 		panic(fmt.Errorf("kInterfaceNaked: unexpected valueType: %d", n.v))
 	}
 	return
 }
 
-func (f *decFnInfo) kInterface(rv reflect.Value) {
-	// debugf("\t===> kInterface")
-
+func (d *Decoder) kInterface(f *codecFnInfo, rv reflect.Value) {
 	// Note:
 	// A consequence of how kInterface works, is that
 	// if an interface already contains something, we try
 	// to decode into what was there before.
 	// We do not replace with a generic value (as got from decodeNaked).
 
+	// every interface passed here MUST be settable.
 	var rvn reflect.Value
 	if rv.IsNil() {
-		rvn = f.kInterfaceNaked()
-		if rvn.IsValid() {
+		if rvn = d.kInterfaceNaked(f); rvn.IsValid() {
 			rv.Set(rvn)
 		}
-	} else if f.d.h.InterfaceReset {
-		rvn = f.kInterfaceNaked()
-		if rvn.IsValid() {
+		return
+	}
+	if d.h.InterfaceReset {
+		if rvn = d.kInterfaceNaked(f); rvn.IsValid() {
 			rv.Set(rvn)
 		} else {
 			// reset to zero value based on current type in there.
 			rv.Set(reflect.Zero(rv.Elem().Type()))
 		}
-	} else {
-		rvn = rv.Elem()
-		// Note: interface{} is settable, but underlying type may not be.
-		// Consequently, we have to set the reflect.Value directly.
-		// if underlying type is settable (e.g. ptr or interface),
-		// we just decode into it.
-		// Else we create a settable value, decode into it, and set on the interface.
-		if rvn.CanSet() {
-			f.d.decodeValue(rvn, nil)
-		} else {
-			rvn2 := reflect.New(rvn.Type()).Elem()
-			rvn2.Set(rvn)
-			f.d.decodeValue(rvn2, nil)
-			rv.Set(rvn2)
-		}
+		return
 	}
+
+	// now we have a non-nil interface value, meaning it contains a type
+	rvn = rv.Elem()
+	if d.d.TryDecodeAsNil() {
+		rv.Set(reflect.Zero(rvn.Type()))
+		return
+	}
+
+	// Note: interface{} is settable, but underlying type may not be.
+	// Consequently, we MAY have to create a decodable value out of the underlying value,
+	// decode into it, and reset the interface itself.
+	// fmt.Printf(">>>> kInterface: rvn type: %v, rv type: %v\n", rvn.Type(), rv.Type())
+
+	rvn2, canDecode := isDecodeable(rvn)
+	if canDecode {
+		d.decodeValue(rvn2, nil, true)
+		return
+	}
+
+	rvn2 = reflect.New(rvn.Type()).Elem()
+	rvn2.Set(rvn)
+	d.decodeValue(rvn2, nil, true)
+	rv.Set(rvn2)
 }
 
-func (f *decFnInfo) kStruct(rv reflect.Value) {
+func decStructFieldKey(dd decDriver, keyType valueType, b *[scratchByteArrayLen]byte) (rvkencname []byte) {
+	switch keyType {
+	case valueTypeString:
+		rvkencname = (dd.DecodeStringAsBytes())
+	case valueTypeInt:
+		rvkencname = (strconv.AppendInt(b[:0], dd.DecodeInt(64), 10))
+	case valueTypeUint:
+		rvkencname = (strconv.AppendUint(b[:0], dd.DecodeUint(64), 10))
+	case valueTypeFloat:
+		rvkencname = (strconv.AppendFloat(b[:0], dd.DecodeFloat64(), 'f', -1, 64))
+	default: // string
+		rvkencname = (dd.DecodeStringAsBytes())
+	}
+	return
+}
+
+func (d *Decoder) kStruct(f *codecFnInfo, rv reflect.Value) {
 	fti := f.ti
-	d := f.d
 	dd := d.d
-	cr := d.cr
+	elemsep := d.esep
+	sfn := structFieldNode{v: rv, update: true}
 	ctyp := dd.ContainerType()
 	if ctyp == valueTypeMap {
 		containerLen := dd.ReadMapStart()
 		if containerLen == 0 {
-			if cr != nil {
-				cr.sendContainerState(containerMapEnd)
-			}
+			dd.ReadMapEnd()
 			return
 		}
 		tisfi := fti.sfi
 		hasLen := containerLen >= 0
+
+		var rvkencname string
 		for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-			// rvkencname := dd.DecodeString()
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if elemsep {
+				dd.ReadMapElemKey()
 			}
-			rvkencnameB := dd.DecodeStringAsBytes()
-			rvkencname := stringView(rvkencnameB)
-			// rvksi := ti.getForEncName(rvkencname)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			rvkencname = stringView(decStructFieldKey(dd, fti.keyType, &d.b))
+			if elemsep {
+				dd.ReadMapElemValue()
 			}
 			if k := fti.indexForEncName(rvkencname); k > -1 {
 				si := tisfi[k]
 				if dd.TryDecodeAsNil() {
 					si.setToZeroValue(rv)
 				} else {
-					d.decodeValue(si.field(rv, true), nil)
+					d.decodeValue(sfn.field(si), nil, true)
 				}
 			} else {
 				d.structFieldNotFound(-1, rvkencname)
 			}
 			// keepAlive4StringView(rvkencnameB) // maintain ref 4 stringView // not needed, as reference is outside loop
 		}
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 	} else if ctyp == valueTypeArray {
 		containerLen := dd.ReadArrayStart()
 		if containerLen == 0 {
-			if cr != nil {
-				cr.sendContainerState(containerArrayEnd)
-			}
+			dd.ReadArrayEnd()
 			return
 		}
 		// Not much gain from doing it two ways for array.
@@ -831,59 +1196,64 @@ func (f *decFnInfo) kStruct(rv reflect.Value) {
 			if (hasLen && j == containerLen) || (!hasLen && dd.CheckBreak()) {
 				break
 			}
-			if cr != nil {
-				cr.sendContainerState(containerArrayElem)
+			if elemsep {
+				dd.ReadArrayElem()
 			}
 			if dd.TryDecodeAsNil() {
 				si.setToZeroValue(rv)
 			} else {
-				d.decodeValue(si.field(rv, true), nil)
+				d.decodeValue(sfn.field(si), nil, true)
 			}
 		}
 		if containerLen > len(fti.sfip) {
 			// read remaining values and throw away
 			for j := len(fti.sfip); j < containerLen; j++ {
-				if cr != nil {
-					cr.sendContainerState(containerArrayElem)
+				if elemsep {
+					dd.ReadArrayElem()
 				}
 				d.structFieldNotFound(j, "")
 			}
 		}
-		if cr != nil {
-			cr.sendContainerState(containerArrayEnd)
-		}
+		dd.ReadArrayEnd()
 	} else {
-		f.d.error(onlyMapOrArrayCanDecodeIntoStructErr)
+		d.errorstr(errstrOnlyMapOrArrayCanDecodeIntoStruct)
 		return
 	}
 }
 
-func (f *decFnInfo) kSlice(rv reflect.Value) {
+func (d *Decoder) kSlice(f *codecFnInfo, rv reflect.Value) {
 	// A slice can be set from a map or array in stream.
 	// This way, the order can be kept (as order is lost with map).
 	ti := f.ti
-	d := f.d
+	if f.seq == seqTypeChan && ti.rt.ChanDir()&reflect.SendDir == 0 {
+		d.errorf("receive-only channel cannot be used for sending byte(s)")
+	}
 	dd := d.d
 	rtelem0 := ti.rt.Elem()
 	ctyp := dd.ContainerType()
 	if ctyp == valueTypeBytes || ctyp == valueTypeString {
 		// you can only decode bytes or string in the stream into a slice or array of bytes
 		if !(ti.rtid == uint8SliceTypId || rtelem0.Kind() == reflect.Uint8) {
-			f.d.errorf("bytes or string in the stream must be decoded into a slice or array of bytes, not %v", ti.rt)
+			d.errorf("bytes or string in the stream must be decoded into a slice or array of bytes, not %v", ti.rt)
 		}
 		if f.seq == seqTypeChan {
 			bs2 := dd.DecodeBytes(nil, true)
-			ch := rv2i(rv).(chan<- byte)
+			irv := rv2i(rv)
+			ch, ok := irv.(chan<- byte)
+			if !ok {
+				ch = irv.(chan byte)
+			}
 			for _, b := range bs2 {
 				ch <- b
 			}
 		} else {
 			rvbs := rv.Bytes()
 			bs2 := dd.DecodeBytes(rvbs, false)
-			if rvbs == nil && bs2 != nil || rvbs != nil && bs2 == nil || len(bs2) != len(rvbs) {
+			// if rvbs == nil && bs2 != nil || rvbs != nil && bs2 == nil || len(bs2) != len(rvbs) {
+			if !(len(bs2) > 0 && len(bs2) == len(rvbs) && &bs2[0] == &rvbs[0]) {
 				if rv.CanSet() {
 					rv.SetBytes(bs2)
-				} else {
+				} else if len(rvbs) > 0 && len(bs2) > 0 {
 					copy(rvbs, bs2)
 				}
 			}
@@ -895,7 +1265,7 @@ func (f *decFnInfo) kSlice(rv reflect.Value) {
 
 	slh, containerLenS := d.decSliceHelperStart() // only expects valueType(Array|Map)
 
-	// // an array can never return a nil slice. so no need to check f.array here.
+	// an array can never return a nil slice. so no need to check f.array here.
 	if containerLenS == 0 {
 		if rv.CanSet() {
 			if f.seq == seqTypeSlice {
@@ -915,75 +1285,94 @@ func (f *decFnInfo) kSlice(rv reflect.Value) {
 	}
 
 	rtelem0Size := int(rtelem0.Size())
-	rtelem0Mut := !isImmutableKind(rtelem0.Kind())
-	// rtelem0Kind := rtelem0.Kind()
+	rtElem0Kind := rtelem0.Kind()
+	rtelem0Mut := !isImmutableKind(rtElem0Kind)
 	rtelem := rtelem0
-	for rtelem.Kind() == reflect.Ptr {
+	rtelemkind := rtelem.Kind()
+	for rtelemkind == reflect.Ptr {
 		rtelem = rtelem.Elem()
+		rtelemkind = rtelem.Kind()
 	}
-	fn := d.getDecFn(rtelem, true, true)
 
-	var rv0, rv9 reflect.Value
-	rv0 = rv
-	rvChanged := false
+	var fn *codecFn
+
+	var rvCanset = rv.CanSet()
+	var rvChanged bool
+	var rv0 = rv
+	var rv9 reflect.Value
 
-	// for j := 0; j < containerLenS; j++ {
 	rvlen := rv.Len()
 	rvcap := rv.Cap()
 	hasLen := containerLenS > 0
 	if hasLen && f.seq == seqTypeSlice {
 		if containerLenS > rvcap {
 			oldRvlenGtZero := rvlen > 0
-			rvlen = decInferLen(containerLenS, f.d.h.MaxInitLen, int(rtelem0.Size()))
+			rvlen = decInferLen(containerLenS, d.h.MaxInitLen, int(rtelem0.Size()))
 			if rvlen <= rvcap {
-				if rv.CanSet() {
+				if rvCanset {
 					rv.SetLen(rvlen)
-				} else {
-					rv = rv.Slice(0, rvlen)
-					rvChanged = true
 				}
-			} else {
+			} else if rvCanset {
 				rv = reflect.MakeSlice(ti.rt, rvlen, rvlen)
 				rvcap = rvlen
 				rvChanged = true
+			} else {
+				d.errorf("cannot decode into non-settable slice")
 			}
 			if rvChanged && oldRvlenGtZero && !isImmutableKind(rtelem0.Kind()) {
 				reflect.Copy(rv, rv0) // only copy up to length NOT cap i.e. rv0.Slice(0, rvcap)
 			}
 		} else if containerLenS != rvlen {
 			rvlen = containerLenS
-			if rv.CanSet() {
+			if rvCanset {
 				rv.SetLen(rvlen)
-			} else {
-				rv = rv.Slice(0, rvlen)
-				rvChanged = true
 			}
+			// else {
+			// rv = rv.Slice(0, rvlen)
+			// rvChanged = true
+			// d.errorf("cannot decode into non-settable slice")
+			// }
 		}
 	}
+
 	// consider creating new element once, and just decoding into it.
 	var rtelem0Zero reflect.Value
 	var rtelem0ZeroValid bool
+	var decodeAsNil bool
 	var j int
 	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
 		if j == 0 && (f.seq == seqTypeSlice || f.seq == seqTypeChan) && rv.IsNil() {
 			if hasLen {
-				rvlen = decInferLen(containerLenS, f.d.h.MaxInitLen, rtelem0Size)
+				rvlen = decInferLen(containerLenS, d.h.MaxInitLen, rtelem0Size)
 			} else {
 				rvlen = 8
 			}
-			if f.seq == seqTypeSlice {
-				rv = reflect.MakeSlice(ti.rt, rvlen, rvlen)
-				rvChanged = true
-			} else if f.seq == seqTypeChan {
-				rv.Set(reflect.MakeChan(ti.rt, rvlen))
+			if rvCanset {
+				if f.seq == seqTypeSlice {
+					rv = reflect.MakeSlice(ti.rt, rvlen, rvlen)
+					rvChanged = true
+				} else { // chan
+					rv = reflect.MakeChan(ti.rt, rvlen)
+					rvChanged = true
+				}
+			} else {
+				d.errorf("cannot decode into non-settable slice")
 			}
 		}
+		slh.ElemContainerState(j)
+		decodeAsNil = dd.TryDecodeAsNil()
 		if f.seq == seqTypeChan {
-			slh.ElemContainerState(j)
-			if rtelem0Mut || !rv9.IsValid() {
+			if decodeAsNil {
+				rv.Send(reflect.Zero(rtelem0))
+				continue
+			}
+			if rtelem0Mut || !rv9.IsValid() { // || (rtElem0Kind == reflect.Ptr && rv9.IsNil()) {
 				rv9 = reflect.New(rtelem0).Elem()
 			}
-			d.decodeValue(rv9, fn)
+			if fn == nil {
+				fn = d.cf.get(rtelem, true, true)
+			}
+			d.decodeValue(rv9, fn, true)
 			rv.Send(rv9)
 		} else {
 			// if indefinite, etc, then expand the slice if necessary
@@ -995,7 +1384,11 @@ func (f *decFnInfo) kSlice(rv reflect.Value) {
 				} else { // if f.seq == seqTypeSlice
 					// rv = reflect.Append(rv, reflect.Zero(rtelem0)) // uses append logic, plus varargs
 					var rvcap2 int
-					rv9, rvcap2, rvChanged = decExpandSliceRV(rv, ti.rt, rtelem0Size, 1, rvlen, rvcap)
+					var rvErrmsg2 string
+					rv9, rvcap2, rvChanged, rvErrmsg2 = expandSliceRV(rv, ti.rt, rvCanset, rtelem0Size, 1, rvlen, rvcap)
+					if rvErrmsg2 != "" {
+						d.errorf(rvErrmsg2)
+					}
 					rvlen++
 					if rvChanged {
 						rv = rv9
@@ -1003,20 +1396,27 @@ func (f *decFnInfo) kSlice(rv reflect.Value) {
 					}
 				}
 			}
-			slh.ElemContainerState(j)
 			if decodeIntoBlank {
-				d.swallow()
+				if !decodeAsNil {
+					d.swallow()
+				}
 			} else {
 				rv9 = rv.Index(j)
-				// rv.Index(rv.Len() - 1).Set(reflect.Zero(rtelem0))
-				if resetSliceElemToZeroValue {
+				if d.h.SliceElementReset || decodeAsNil {
 					if !rtelem0ZeroValid {
 						rtelem0ZeroValid = true
 						rtelem0Zero = reflect.Zero(rtelem0)
 					}
 					rv9.Set(rtelem0Zero)
 				}
-				d.decodeValue(rv9, fn)
+				if decodeAsNil {
+					continue
+				}
+
+				if fn == nil {
+					fn = d.cf.get(rtelem, true, true)
+				}
+				d.decodeValue(rv9, fn, true)
 			}
 		}
 	}
@@ -1024,59 +1424,59 @@ func (f *decFnInfo) kSlice(rv reflect.Value) {
 		if j < rvlen {
 			if rv.CanSet() {
 				rv.SetLen(j)
-			} else {
+			} else if rvCanset {
 				rv = rv.Slice(0, j)
 				rvChanged = true
-			}
+			} // else { d.errorf("kSlice: cannot change non-settable slice") }
 			rvlen = j
 		} else if j == 0 && rv.IsNil() {
-			rv = reflect.MakeSlice(ti.rt, 0, 0)
-			rvChanged = true
+			if rvCanset {
+				rv = reflect.MakeSlice(ti.rt, 0, 0)
+				rvChanged = true
+			} // else { d.errorf("kSlice: cannot change non-settable slice") }
 		}
 	}
 	slh.End()
 
-	if rvChanged {
+	if rvChanged { // infers rvCanset=true, so it can be reset
 		rv0.Set(rv)
 	}
 }
 
-func (f *decFnInfo) kArray(rv reflect.Value) {
-	// f.d.decodeValue(rv.Slice(0, rv.Len()))
-	f.kSlice(rv.Slice(0, rv.Len()))
-}
+// func (d *Decoder) kArray(f *codecFnInfo, rv reflect.Value) {
+// 	// d.decodeValueFn(rv.Slice(0, rv.Len()))
+// 	f.kSlice(rv.Slice(0, rv.Len()))
+// }
 
-func (f *decFnInfo) kMap(rv reflect.Value) {
-	d := f.d
+func (d *Decoder) kMap(f *codecFnInfo, rv reflect.Value) {
 	dd := d.d
 	containerLen := dd.ReadMapStart()
-	cr := d.cr
+	elemsep := d.esep
 	ti := f.ti
 	if rv.IsNil() {
 		rv.Set(makeMapReflect(ti.rt, containerLen))
 	}
 
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return
 	}
 
 	ktype, vtype := ti.rt.Key(), ti.rt.Elem()
 	ktypeId := rt2id(ktype)
 	vtypeKind := vtype.Kind()
-	var keyFn, valFn *decFn
-	var xtyp reflect.Type
-	for xtyp = ktype; xtyp.Kind() == reflect.Ptr; xtyp = xtyp.Elem() {
+
+	var keyFn, valFn *codecFn
+	var ktypeLo, vtypeLo reflect.Type
+	for ktypeLo = ktype; ktypeLo.Kind() == reflect.Ptr; ktypeLo = ktypeLo.Elem() {
 	}
-	keyFn = d.getDecFn(xtyp, true, true)
-	for xtyp = vtype; xtyp.Kind() == reflect.Ptr; xtyp = xtyp.Elem() {
+
+	for vtypeLo = vtype; vtypeLo.Kind() == reflect.Ptr; vtypeLo = vtypeLo.Elem() {
 	}
-	valFn = d.getDecFn(xtyp, true, true)
+
 	var mapGet, mapSet bool
 	rvvImmut := isImmutableKind(vtypeKind)
-	if !f.d.h.MapValueReset {
+	if !d.h.MapValueReset {
 		// if pointer, mapGet = true
 		// if interface, mapGet = true if !DecodeNakedAlways (else false)
 		// if builtin, mapGet = false
@@ -1084,7 +1484,7 @@ func (f *decFnInfo) kMap(rv reflect.Value) {
 		if vtypeKind == reflect.Ptr {
 			mapGet = true
 		} else if vtypeKind == reflect.Interface {
-			if !f.d.h.InterfaceReset {
+			if !d.h.InterfaceReset {
 				mapGet = true
 			}
 		} else if !rvvImmut {
@@ -1092,38 +1492,49 @@ func (f *decFnInfo) kMap(rv reflect.Value) {
 		}
 	}
 
-	var rvk, rvv, rvz reflect.Value
+	var rvk, rvkp, rvv, rvz reflect.Value
 	rvkMut := !isImmutableKind(ktype.Kind()) // if ktype is immutable, then re-use the same rvk.
 	ktypeIsString := ktypeId == stringTypId
-	// ktypeIsString = false
 	ktypeIsIntf := ktypeId == intfTypId
 	hasLen := containerLen > 0
 	var kstrbs []byte
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if rvkMut || !rvkp.IsValid() {
+			rvkp = reflect.New(ktype)
+			rvk = rvkp.Elem()
 		}
-		if rvkMut || !rvk.IsValid() {
-			rvk = reflect.New(ktype).Elem()
+		if elemsep {
+			dd.ReadMapElemKey()
 		}
-		if ktypeIsString {
+		if false && dd.TryDecodeAsNil() { // nil cannot be a map key, so disregard this block
+			// Previously, if a nil key, we just ignored the mapped value and continued.
+			// However, that makes the result of encoding and then decoding map[intf]intf{nil:nil}
+			// to be an empty map.
+			// Instead, we treat a nil key as the zero value of the type.
+			rvk.Set(reflect.Zero(ktype))
+		} else if ktypeIsString {
 			kstrbs = dd.DecodeStringAsBytes()
-			// fmt.Printf(">>>> decode: kMap: kstring: %s\n", kstrbs)
 			rvk.SetString(stringView(kstrbs))
 			// NOTE: if doing an insert, you MUST use a real string (not stringview)
 		} else {
-			d.decodeValue(rvk, keyFn)
-			// special case if a byte array.
-			if ktypeIsIntf {
-				rvk = rvk.Elem()
-				if rvk.Type() == uint8SliceTyp {
-					rvk = reflect.ValueOf(d.string(rvk.Bytes()))
+			if keyFn == nil {
+				keyFn = d.cf.get(ktypeLo, true, true)
+			}
+			d.decodeValue(rvk, keyFn, true)
+		}
+		// special case if a byte array.
+		if ktypeIsIntf {
+			if rvk2 := rvk.Elem(); rvk2.IsValid() {
+				if rvk2.Type() == uint8SliceTyp {
+					rvk = reflect.ValueOf(d.string(rvk2.Bytes()))
+				} else {
+					rvk = rvk2
 				}
 			}
 		}
 
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if elemsep {
+			dd.ReadMapElemValue()
 		}
 
 		// Brittle, but OK per TryDecodeAsNil() contract.
@@ -1132,25 +1543,36 @@ func (f *decFnInfo) kMap(rv reflect.Value) {
 			if ktypeIsString {
 				rvk.SetString(d.string(kstrbs))
 			}
-			rv.SetMapIndex(rvk, reflect.Value{}) // delete the mapping
+			if d.h.DeleteOnNilMapValue {
+				rv.SetMapIndex(rvk, reflect.Value{})
+			} else {
+				rv.SetMapIndex(rvk, reflect.Zero(vtype))
+			}
 			continue
 		}
 
-		mapSet = true // set to false if u do a get, and its a pointer, and exists
+		mapSet = true // set to false if u do a get, and its a non-nil pointer
 		if mapGet {
+			// mapGet true only in case where kind=Ptr|Interface or kind is otherwise mutable.
 			rvv = rv.MapIndex(rvk)
 			if !rvv.IsValid() {
 				rvv = reflect.New(vtype).Elem()
 			} else if vtypeKind == reflect.Ptr {
-				mapSet = false
+				if rvv.IsNil() {
+					rvv = reflect.New(vtype).Elem()
+				} else {
+					mapSet = false
+				}
+			} else if vtypeKind == reflect.Interface {
+				// not addressable, and thus not settable.
+				// e MUST create a settable/addressable variant
+				rvv2 := reflect.New(rvv.Type()).Elem()
+				if !rvv.IsNil() {
+					rvv2.Set(rvv)
+				}
+				rvv = rvv2
 			}
-			// if rvv.IsValid() {
-			// 	if vtypeKind == reflect.Ptr {
-			// 		mapSet = false
-			// 	}
-			// } else {
-			// 	rvv = reflect.New(vtype).Elem()
-			// }
+			// else it is ~mutable, and we can just decode into it directly
 		} else if rvvImmut {
 			if !rvz.IsValid() {
 				rvz = reflect.New(vtype).Elem()
@@ -1162,28 +1584,23 @@ func (f *decFnInfo) kMap(rv reflect.Value) {
 
 		// We MUST be done with the stringview of the key, before decoding the value
 		// so that we don't bastardize the reused byte array.
+		if mapSet && ktypeIsString {
+			rvk.SetString(d.string(kstrbs))
+		}
+		if valFn == nil {
+			valFn = d.cf.get(vtypeLo, true, true)
+		}
+		d.decodeValue(rvv, valFn, true)
+		// d.decodeValueFn(rvv, valFn)
 		if mapSet {
-			if ktypeIsString {
-				rvk.SetString(d.string(kstrbs))
-			}
-			d.decodeValue(rvv, valFn)
 			rv.SetMapIndex(rvk, rvv)
-		} else {
-			d.decodeValue(rvv, valFn)
 		}
 		// if ktypeIsString {
 		// 	// keepAlive4StringView(kstrbs) // not needed, as reference is outside loop
 		// }
 	}
 
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
-}
-
-type decRtidFn struct {
-	rtid uintptr
-	fn   decFn
+	dd.ReadMapEnd()
 }
 
 // decNaked is used to keep track of the primitives decoded.
@@ -1212,37 +1629,75 @@ type decNaked struct {
 	l []byte
 	s string
 	t time.Time
+
 	b bool
+
+	inited bool
+
 	v valueType
 
-	// stacks for reducing allocation
-	is []interface{}
-	ms []map[interface{}]interface{}
-	ns []map[string]interface{}
-	ss [][]interface{}
-	// rs []RawExt
+	li, lm, ln, ls int8
 
+	// array/stacks for reducing allocation
 	// keep arrays at the bottom? Chance is that they are not used much.
-	ia [4]interface{}
-	ma [4]map[interface{}]interface{}
-	na [4]map[string]interface{}
-	sa [4][]interface{}
+	ia [arrayCacheLen]interface{}
+	ma [arrayCacheLen]map[interface{}]interface{}
+	na [arrayCacheLen]map[string]interface{}
+	sa [arrayCacheLen][]interface{}
 	// ra [2]RawExt
+
+	rr [5 * arrayCacheLen]reflect.Value
+}
+
+const (
+	decNakedUintIdx = iota
+	decNakedIntIdx
+	decNakedFloatIdx
+	decNakedBytesIdx
+	decNakedStringIdx
+	decNakedTimeIdx
+	decNakedBoolIdx
+)
+const (
+	_ = iota // maps to the scalars above
+	decNakedIntfIdx
+	decNakedMapIntfIntfIdx
+	decNakedMapStrIntfIdx
+	decNakedSliceIntfIdx
+)
+
+func (n *decNaked) init() {
+	if n.inited {
+		return
+	}
+	// n.ms = n.ma[:0]
+	// n.is = n.ia[:0]
+	// n.ns = n.na[:0]
+	// n.ss = n.sa[:0]
+
+	n.rr[decNakedUintIdx] = reflect.ValueOf(&n.u).Elem()
+	n.rr[decNakedIntIdx] = reflect.ValueOf(&n.i).Elem()
+	n.rr[decNakedFloatIdx] = reflect.ValueOf(&n.f).Elem()
+	n.rr[decNakedBytesIdx] = reflect.ValueOf(&n.l).Elem()
+	n.rr[decNakedStringIdx] = reflect.ValueOf(&n.s).Elem()
+	n.rr[decNakedTimeIdx] = reflect.ValueOf(&n.t).Elem()
+	n.rr[decNakedBoolIdx] = reflect.ValueOf(&n.b).Elem()
+
+	for i := range [arrayCacheLen]struct{}{} {
+		n.rr[decNakedIntfIdx*arrayCacheLen+i] = reflect.ValueOf(&(n.ia[i])).Elem()
+		n.rr[decNakedMapIntfIntfIdx*arrayCacheLen+i] = reflect.ValueOf(&(n.ma[i])).Elem()
+		n.rr[decNakedMapStrIntfIdx*arrayCacheLen+i] = reflect.ValueOf(&(n.na[i])).Elem()
+		n.rr[decNakedSliceIntfIdx*arrayCacheLen+i] = reflect.ValueOf(&(n.sa[i])).Elem()
+	}
+	n.inited = true
+	// n.rr[] = reflect.ValueOf(&n.)
 }
 
 func (n *decNaked) reset() {
-	if n.ss != nil {
-		n.ss = n.ss[:0]
-	}
-	if n.is != nil {
-		n.is = n.is[:0]
-	}
-	if n.ms != nil {
-		n.ms = n.ms[:0]
-	}
-	if n.ns != nil {
-		n.ns = n.ns[:0]
+	if n == nil {
+		return
 	}
+	n.li, n.lm, n.ln, n.ls = 0, 0, 0, 0
 }
 
 type rtid2rv struct {
@@ -1250,41 +1705,124 @@ type rtid2rv struct {
 	rv   reflect.Value
 }
 
+// --------------
+
+type decReaderSwitch struct {
+	rb bytesDecReader
+	// ---- cpu cache line boundary?
+	ri       ioDecReader
+	mtr, str bool // whether maptype or slicetype are known types
+
+	be    bool // is binary encoding
+	bytes bool // is bytes reader
+	js    bool // is json handle
+	jsms  bool // is json handle, and MapKeyAsString
+	esep  bool // has elem separators
+}
+
+// TODO: Uncomment after mid-stack inlining enabled in go 1.10
+//
+// func (z *decReaderSwitch) unreadn1() {
+// 	if z.bytes {
+// 		z.rb.unreadn1()
+// 	} else {
+// 		z.ri.unreadn1()
+// 	}
+// }
+// func (z *decReaderSwitch) readx(n int) []byte {
+// 	if z.bytes {
+// 		return z.rb.readx(n)
+// 	}
+// 	return z.ri.readx(n)
+// }
+// func (z *decReaderSwitch) readb(s []byte) {
+// 	if z.bytes {
+// 		z.rb.readb(s)
+// 	} else {
+// 		z.ri.readb(s)
+// 	}
+// }
+// func (z *decReaderSwitch) readn1() uint8 {
+// 	if z.bytes {
+// 		return z.rb.readn1()
+// 	}
+// 	return z.ri.readn1()
+// }
+// func (z *decReaderSwitch) numread() int {
+// 	if z.bytes {
+// 		return z.rb.numread()
+// 	}
+// 	return z.ri.numread()
+// }
+// func (z *decReaderSwitch) track() {
+// 	if z.bytes {
+// 		z.rb.track()
+// 	} else {
+// 		z.ri.track()
+// 	}
+// }
+// func (z *decReaderSwitch) stopTrack() []byte {
+// 	if z.bytes {
+// 		return z.rb.stopTrack()
+// 	}
+// 	return z.ri.stopTrack()
+// }
+// func (z *decReaderSwitch) skip(accept *bitset256) (token byte) {
+// 	if z.bytes {
+// 		return z.rb.skip(accept)
+// 	}
+// 	return z.ri.skip(accept)
+// }
+// func (z *decReaderSwitch) readTo(in []byte, accept *bitset256) (out []byte) {
+// 	if z.bytes {
+// 		return z.rb.readTo(in, accept)
+// 	}
+// 	return z.ri.readTo(in, accept)
+// }
+// func (z *decReaderSwitch) readUntil(in []byte, stop byte) (out []byte) {
+// 	if z.bytes {
+// 		return z.rb.readUntil(in, stop)
+// 	}
+// 	return z.ri.readUntil(in, stop)
+// }
+
 // A Decoder reads and decodes an object from an input stream in the codec format.
 type Decoder struct {
+	panicHdl
 	// hopefully, reduce derefencing cost by laying the decReader inside the Decoder.
 	// Try to put things that go together to fit within a cache line (8 words).
 
 	d decDriver
 	// NOTE: Decoder shouldn't call it's read methods,
 	// as the handler MAY need to do some coordination.
-	r decReader
-	// sa [initCollectionCap]decRtidFn
-	h  *BasicHandle
+	r  decReader
 	hh Handle
+	h  *BasicHandle
 
-	be    bool // is binary encoding
-	bytes bool // is bytes reader
-	js    bool // is json handle
-
-	rb bytesDecReader
-	ri ioDecReader
-	cr containerStateRecv
-
-	s []decRtidFn
-	f map[uintptr]*decFn
-
-	// _  uintptr // for alignment purposes, so next one starts from a cache line
-
+	// ---- cpu cache line boundary?
+	decReaderSwitch
+	// ---- cpu cache line boundary?
+	bi bufioDecReader
+	// ---- cpu cache line boundary?
+	cf codecFner
+	// ---- cpu cache line boundary?
+	// cr containerStateRecv
+	is map[string]string // used for interning strings
 	// cache the mapTypeId and sliceTypeId for faster comparisons
 	mtid uintptr
 	stid uintptr
+	// _  uintptr // for alignment purposes, so next one starts from a cache line
 
-	n  decNaked
-	np ptrToRvMap
-	b  [scratchByteArrayLen]byte
-	is map[string]string // used for interning strings
-	zc []rtid2rv         // zero-valued cache
+	// ---- writable fields during execution --- *try* to keep in sep cache line
+
+	// ---- cpu cache line boundary?
+	b   [scratchByteArrayLen]byte
+	n   *decNaked
+	nsp *sync.Pool
+	err error
+	// ---- cpu cache line boundary?
+
+	// _ [64]byte // force alignment???
 }
 
 // NewDecoder returns a Decoder for decoding a stream of bytes from an io.Reader.
@@ -1305,66 +1843,95 @@ func NewDecoderBytes(in []byte, h Handle) *Decoder {
 	return d
 }
 
+var defaultDecNaked decNaked
+
 func newDecoder(h Handle) *Decoder {
-	d := &Decoder{hh: h, h: h.getBasicHandle(), be: h.isBinary()}
-	d.np.init()
-	n := &d.n
-	// n.rs = n.ra[:0]
-	n.ms = n.ma[:0]
-	n.is = n.ia[:0]
-	n.ns = n.na[:0]
-	n.ss = n.sa[:0]
-	_, d.js = h.(*JsonHandle)
+	d := &Decoder{hh: h, h: h.getBasicHandle()}
+	d.be = h.isBinary()
+	// NOTE: do not initialize d.n here. It is lazily initialized in d.naked()
+	var jh *JsonHandle
+	jh, d.js = h.(*JsonHandle)
+	if d.js {
+		d.jsms = jh.MapKeyAsString
+	}
+	d.esep = d.hh.hasElemSeparators()
 	if d.h.InternString {
 		d.is = make(map[string]string, 32)
 	}
 	d.d = h.newDecDriver(d)
-	d.cr, _ = d.d.(containerStateRecv)
-	// d.d = h.newDecDriver(decReaderT{true, &d.rb, &d.ri})
+	// d.cr, _ = d.d.(containerStateRecv)
 	return d
 }
 
+// naked must be called before each call to .DecodeNaked,
+// as they will use it.
+func (d *Decoder) naked() *decNaked {
+	if d.n == nil {
+		// consider one of:
+		//   - get from sync.Pool  (if GC is frequent, there's no value here)
+		//   - new alloc           (safest. only init'ed if it a naked decode will be done)
+		//   - field in Decoder    (makes the Decoder struct very big)
+		// To support using a decoder where a DecodeNaked is not needed,
+		// we prefer #1 or #2.
+		// d.n = new(decNaked) // &d.nv // new(decNaked) // grab from a sync.Pool
+		// d.n.init()
+		var v interface{}
+		d.nsp, v = pool.decNaked()
+		d.n = v.(*decNaked)
+	}
+	return d.n
+}
+
 func (d *Decoder) resetCommon() {
 	d.n.reset()
 	d.d.reset()
-	// reset all things which were cached from the Handle,
-	// but could be changed.
+	d.cf.reset(d.hh)
+	d.err = nil
+	// reset all things which were cached from the Handle, but could change
 	d.mtid, d.stid = 0, 0
+	d.mtr, d.str = false, false
 	if d.h.MapType != nil {
 		d.mtid = rt2id(d.h.MapType)
+		d.mtr = fastpathAV.index(d.mtid) != -1
 	}
 	if d.h.SliceType != nil {
 		d.stid = rt2id(d.h.SliceType)
+		d.str = fastpathAV.index(d.stid) != -1
 	}
 }
 
+// Reset the Decoder with a new Reader to decode from,
+// clearing all state from last run(s).
 func (d *Decoder) Reset(r io.Reader) {
-	d.ri.x = &d.b
-	// d.s = d.sa[:0]
-	d.ri.bs.r = r
-	var ok bool
-	d.ri.br, ok = r.(decReaderByteScanner)
-	if !ok {
-		d.ri.br = &d.ri.bs
+	if r == nil {
+		return
+	}
+	d.bytes = false
+	if d.h.ReaderBufferSize > 0 {
+		d.bi.buf = make([]byte, 0, d.h.ReaderBufferSize)
+		d.bi.reset(r)
+		d.r = &d.bi
+	} else {
+		d.ri.x = &d.b
+		// d.s = d.sa[:0]
+		d.ri.reset(r)
+		d.r = &d.ri
 	}
-	d.r = &d.ri
 	d.resetCommon()
 }
 
+// ResetBytes resets the Decoder with a new []byte to decode from,
+// clearing all state from last run(s).
 func (d *Decoder) ResetBytes(in []byte) {
-	// d.s = d.sa[:0]
+	if in == nil {
+		return
+	}
 	d.bytes = true
 	d.rb.reset(in)
 	d.r = &d.rb
 	d.resetCommon()
 }
 
-// func (d *Decoder) sendContainerState(c containerState) {
-// 	if d.cr != nil {
-// 		d.cr.sendContainerState(c)
-// 	}
-// }
-
 // Decode decodes the stream from reader and stores the result in the
 // value pointed to by v. v cannot be a nil pointer. v can also be
 // a reflect.Value of a pointer.
@@ -1415,16 +1982,40 @@ func (d *Decoder) ResetBytes(in []byte) {
 // However, when decoding a stream nil, we reset the destination container
 // to its "zero" value (e.g. nil for slice/map, etc).
 //
+// Note: we allow nil values in the stream anywhere except for map keys.
+// A nil value in the encoded stream where a map key is expected is treated as an error.
 func (d *Decoder) Decode(v interface{}) (err error) {
-	defer panicToErr(&err)
-	d.decode(v)
+	defer panicToErrs2(d, &d.err, &err)
+	d.MustDecode(v)
 	return
 }
 
+// MustDecode is like Decode, but panics if unable to Decode.
+// This provides insight to the code location that triggered the error.
+func (d *Decoder) MustDecode(v interface{}) {
+	// TODO: Top-level: ensure that v is a pointer and not nil.
+	if d.err != nil {
+		panic(d.err)
+	}
+	if d.d.TryDecodeAsNil() {
+		setZero(v)
+	} else {
+		d.decode(v)
+	}
+	if d.n != nil {
+		// if d.n != nil { }
+		// if nsp != nil, then n != nil (they are always set together)
+		d.nsp.Put(d.n)
+		d.n = nil
+		d.nsp = nil
+	}
+	// xprintf(">>>>>>>> >>>>>>>> num decFns: %v\n", d.cf.sn)
+}
+
 // // this is not a smart swallow, as it allocates objects and does unnecessary work.
 // func (d *Decoder) swallowViaHammer() {
 // 	var blank interface{}
-// 	d.decodeValue(reflect.ValueOf(&blank).Elem(), nil)
+// 	d.decodeValueNoFn(reflect.ValueOf(&blank).Elem())
 // }
 
 func (d *Decoder) swallow() {
@@ -1433,37 +2024,33 @@ func (d *Decoder) swallow() {
 	if dd.TryDecodeAsNil() {
 		return
 	}
-	cr := d.cr
+	elemsep := d.esep
 	switch dd.ContainerType() {
 	case valueTypeMap:
 		containerLen := dd.ReadMapStart()
 		hasLen := containerLen >= 0
 		for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
 			// if clenGtEqualZero {if j >= containerLen {break} } else if dd.CheckBreak() {break}
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if elemsep {
+				dd.ReadMapElemKey()
 			}
 			d.swallow()
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if elemsep {
+				dd.ReadMapElemValue()
 			}
 			d.swallow()
 		}
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 	case valueTypeArray:
 		containerLen := dd.ReadArrayStart()
 		hasLen := containerLen >= 0
 		for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-			if cr != nil {
-				cr.sendContainerState(containerArrayElem)
+			if elemsep {
+				dd.ReadArrayElem()
 			}
 			d.swallow()
 		}
-		if cr != nil {
-			cr.sendContainerState(containerArrayEnd)
-		}
+		dd.ReadArrayEnd()
 	case valueTypeBytes:
 		dd.DecodeBytes(d.b[:], true)
 	case valueTypeString:
@@ -1471,101 +2058,96 @@ func (d *Decoder) swallow() {
 	default:
 		// these are all primitives, which we can get from decodeNaked
 		// if RawExt using Value, complete the processing.
+		n := d.naked()
 		dd.DecodeNaked()
-		if n := &d.n; n.v == valueTypeExt && n.l == nil {
-			l := len(n.is)
-			n.is = append(n.is, nil)
-			v2 := &n.is[l]
-			d.decode(v2)
-			n.is = n.is[:l]
+		if n.v == valueTypeExt && n.l == nil {
+			if n.li < arrayCacheLen {
+				n.ia[n.li] = nil
+				n.li++
+				d.decode(&n.ia[n.li-1])
+				n.ia[n.li-1] = nil
+				n.li--
+			} else {
+				var v2 interface{}
+				d.decode(&v2)
+			}
 		}
 	}
 }
 
-// MustDecode is like Decode, but panics if unable to Decode.
-// This provides insight to the code location that triggered the error.
-func (d *Decoder) MustDecode(v interface{}) {
-	d.decode(v)
+func setZero(iv interface{}) {
+	if iv == nil || definitelyNil(iv) {
+		return
+	}
+	var canDecode bool
+	switch v := iv.(type) {
+	case *string:
+		*v = ""
+	case *bool:
+		*v = false
+	case *int:
+		*v = 0
+	case *int8:
+		*v = 0
+	case *int16:
+		*v = 0
+	case *int32:
+		*v = 0
+	case *int64:
+		*v = 0
+	case *uint:
+		*v = 0
+	case *uint8:
+		*v = 0
+	case *uint16:
+		*v = 0
+	case *uint32:
+		*v = 0
+	case *uint64:
+		*v = 0
+	case *float32:
+		*v = 0
+	case *float64:
+		*v = 0
+	case *[]uint8:
+		*v = nil
+	case *Raw:
+		*v = nil
+	case *time.Time:
+		*v = time.Time{}
+	case reflect.Value:
+		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) {
+			v := reflect.ValueOf(iv)
+			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???
+		}
+	}
 }
 
 func (d *Decoder) decode(iv interface{}) {
-	// if ics, ok := iv.(Selfer); ok {
-	// 	ics.CodecDecodeSelf(d)
-	// 	return
-	// }
-
-	if d.d.TryDecodeAsNil() {
-		switch v := iv.(type) {
-		case nil:
-		case *string:
-			*v = ""
-		case *bool:
-			*v = false
-		case *int:
-			*v = 0
-		case *int8:
-			*v = 0
-		case *int16:
-			*v = 0
-		case *int32:
-			*v = 0
-		case *int64:
-			*v = 0
-		case *uint:
-			*v = 0
-		case *uint8:
-			*v = 0
-		case *uint16:
-			*v = 0
-		case *uint32:
-			*v = 0
-		case *uint64:
-			*v = 0
-		case *float32:
-			*v = 0
-		case *float64:
-			*v = 0
-		case *[]uint8:
-			*v = nil
-		case *Raw:
-			*v = nil
-		case reflect.Value:
-			if v.Kind() != reflect.Ptr || v.IsNil() {
-				d.errNotValidPtrValue(v)
-			}
-			// d.chkPtrValue(v)
-			v = v.Elem()
-			if v.IsValid() {
-				v.Set(reflect.Zero(v.Type()))
-			}
-		default:
-			rv := reflect.ValueOf(iv)
-			if rv.Kind() != reflect.Ptr || rv.IsNil() {
-				d.errNotValidPtrValue(rv)
-			}
-			// d.chkPtrValue(rv)
-			rv = rv.Elem()
-			if rv.IsValid() {
-				rv.Set(reflect.Zero(rv.Type()))
-			}
-		}
+	// check nil and interfaces explicitly,
+	// so that type switches just have a run of constant non-interface types.
+	if iv == nil {
+		d.errorstr(errstrCannotDecodeIntoNil)
+		return
+	}
+	if v, ok := iv.(Selfer); ok {
+		v.CodecDecodeSelf(d)
 		return
 	}
 
 	switch v := iv.(type) {
-	case nil:
-		d.error(cannotDecodeIntoNilErr)
-		return
-
-	case Selfer:
-		v.CodecDecodeSelf(d)
+	// case nil:
+	// case Selfer:
 
 	case reflect.Value:
-		if v.Kind() != reflect.Ptr || v.IsNil() {
-			d.errNotValidPtrValue(v)
-		}
-		// d.chkPtrValue(v)
-		d.decodeValueNotNil(v.Elem())
+		v = d.ensureDecodeable(v)
+		d.decodeValue(v, nil, true)
 
 	case *string:
 		*v = d.d.DecodeString()
@@ -1592,230 +2174,76 @@ func (d *Decoder) decode(iv interface{}) {
 	case *uint64:
 		*v = d.d.DecodeUint(64)
 	case *float32:
-		*v = float32(d.d.DecodeFloat(true))
+		f64 := d.d.DecodeFloat64()
+		if chkOvf.Float32(f64) {
+			d.errorf("float32 overflow: %v", f64)
+		}
+		*v = float32(f64)
 	case *float64:
-		*v = d.d.DecodeFloat(false)
+		*v = d.d.DecodeFloat64()
 	case *[]uint8:
 		*v = d.d.DecodeBytes(*v, false)
-
+	case []uint8:
+		b := d.d.DecodeBytes(v, false)
+		if !(len(b) > 0 && len(b) == len(v) && &b[0] == &v[0]) {
+			copy(v, b)
+		}
+	case *time.Time:
+		*v = d.d.DecodeTime()
 	case *Raw:
-		*v = d.raw()
+		*v = d.rawBytes()
 
 	case *interface{}:
-		d.decodeValueNotNil(reflect.ValueOf(iv).Elem())
+		d.decodeValue(reflect.ValueOf(iv).Elem(), nil, true)
+		// d.decodeValueNotNil(reflect.ValueOf(iv).Elem())
 
 	default:
 		if !fastpathDecodeTypeSwitch(iv, d) {
-			d.decodeI(iv, true, false, false, false)
+			v := reflect.ValueOf(iv)
+			v = d.ensureDecodeable(v)
+			d.decodeValue(v, nil, false)
+			// d.decodeValueFallback(v)
 		}
 	}
 }
 
-func (d *Decoder) preDecodeValue(rv reflect.Value, tryNil bool) (rv2 reflect.Value, proceed bool) {
-	if tryNil && d.d.TryDecodeAsNil() {
-		// No need to check if a ptr, recursively, to determine whether to set value to nil.
-		// Just always set value to its zero type.
-		if rv.IsValid() { // rv.CanSet() // always settable, except it's invalid
-			rv.Set(reflect.Zero(rv.Type()))
-		}
-		return
-	}
-
+func (d *Decoder) decodeValue(rv reflect.Value, fn *codecFn, chkAll bool) {
 	// If stream is not containing a nil value, then we can deref to the base
 	// non-pointer value, and decode into that.
-	for rv.Kind() == reflect.Ptr {
-		if rv.IsNil() {
-			rv.Set(reflect.New(rv.Type().Elem()))
-		}
-		rv = rv.Elem()
-	}
-	return rv, true
-}
-
-func (d *Decoder) decodeI(iv interface{}, checkPtr, tryNil, checkFastpath, checkCodecSelfer bool) {
-	rv := reflect.ValueOf(iv)
-	if checkPtr {
-		if rv.Kind() != reflect.Ptr || rv.IsNil() {
-			d.errNotValidPtrValue(rv)
-		}
-		// d.chkPtrValue(rv)
-	}
-	rv, proceed := d.preDecodeValue(rv, tryNil)
-	if proceed {
-		fn := d.getDecFn(rv.Type(), checkFastpath, checkCodecSelfer)
-		fn.f(&fn.i, rv)
-	}
-}
-
-func (d *Decoder) decodeValue(rv reflect.Value, fn *decFn) {
-	if rv, proceed := d.preDecodeValue(rv, true); proceed {
-		if fn == nil {
-			fn = d.getDecFn(rv.Type(), true, true)
-		}
-		fn.f(&fn.i, rv)
-	}
-}
-
-func (d *Decoder) decodeValueNotNil(rv reflect.Value) {
-	if rv, proceed := d.preDecodeValue(rv, false); proceed {
-		fn := d.getDecFn(rv.Type(), true, true)
-		fn.f(&fn.i, rv)
-	}
-}
-
-func (d *Decoder) getDecFn(rt reflect.Type, checkFastpath, checkCodecSelfer bool) (fn *decFn) {
-	rtid := rt2id(rt)
-
-	// retrieve or register a focus'ed function for this type
-	// to eliminate need to do the retrieval multiple times
-
-	// if d.f == nil && d.s == nil { debugf("---->Creating new dec f map for type: %v\n", rt) }
-	var ok bool
-	if useMapForCodecCache {
-		fn, ok = d.f[rtid]
-	} else {
-		for i := range d.s {
-			v := &(d.s[i])
-			if v.rtid == rtid {
-				fn, ok = &(v.fn), true
+	var rvp reflect.Value
+	var rvpValid bool
+	if rv.Kind() == reflect.Ptr {
+		rvpValid = true
+		for {
+			if rv.IsNil() {
+				rv.Set(reflect.New(rv.Type().Elem()))
+			}
+			rvp = rv
+			rv = rv.Elem()
+			if rv.Kind() != reflect.Ptr {
 				break
 			}
 		}
 	}
-	if ok {
-		return
-	}
 
-	if useMapForCodecCache {
-		if d.f == nil {
-			d.f = make(map[uintptr]*decFn, initCollectionCap)
+	if fn == nil {
+		// always pass checkCodecSelfer=true, in case T or ****T is passed, where *T is a Selfer
+		fn = d.cf.get(rv.Type(), chkAll, true) // chkAll, chkAll)
+	}
+	if fn.i.addrD {
+		if rvpValid {
+			fn.fd(d, &fn.i, rvp)
+		} else if rv.CanAddr() {
+			fn.fd(d, &fn.i, rv.Addr())
+		} else if !fn.i.addrF {
+			fn.fd(d, &fn.i, rv)
+		} else {
+			d.errorf("cannot decode into a non-pointer value")
 		}
-		fn = new(decFn)
-		d.f[rtid] = fn
 	} else {
-		if d.s == nil {
-			d.s = make([]decRtidFn, 0, initCollectionCap)
-		}
-		d.s = append(d.s, decRtidFn{rtid: rtid})
-		fn = &(d.s[len(d.s)-1]).fn
+		fn.fd(d, &fn.i, rv)
 	}
-
-	// debugf("\tCreating new dec fn for type: %v\n", rt)
-	ti := d.h.getTypeInfo(rtid, rt)
-	fi := &(fn.i)
-	fi.d = d
-	fi.ti = ti
-
-	// An extension can be registered for any type, regardless of the Kind
-	// (e.g. type BitSet int64, type MyStruct { / * unexported fields * / }, type X []int, etc.
-	//
-	// We can't check if it's an extension byte here first, because the user may have
-	// registered a pointer or non-pointer type, meaning we may have to recurse first
-	// before matching a mapped type, even though the extension byte is already detected.
-	//
-	// NOTE: if decoding into a nil interface{}, we return a non-nil
-	// value except even if the container registers a length of 0.
-	if checkCodecSelfer && ti.cs {
-		fn.f = (*decFnInfo).selferUnmarshal
-	} else if rtid == rawExtTypId {
-		fn.f = (*decFnInfo).rawExt
-	} else if rtid == rawTypId {
-		fn.f = (*decFnInfo).raw
-	} else if d.d.IsBuiltinType(rtid) {
-		fn.f = (*decFnInfo).builtin
-	} else if xfFn := d.h.getExt(rtid); xfFn != nil {
-		fi.xfTag, fi.xfFn = xfFn.tag, xfFn.ext
-		fn.f = (*decFnInfo).ext
-	} else if supportMarshalInterfaces && d.be && ti.bunm {
-		fn.f = (*decFnInfo).binaryUnmarshal
-	} else if supportMarshalInterfaces && !d.be && d.js && ti.junm {
-		//If JSON, we should check JSONUnmarshal before textUnmarshal
-		fn.f = (*decFnInfo).jsonUnmarshal
-	} else if supportMarshalInterfaces && !d.be && ti.tunm {
-		fn.f = (*decFnInfo).textUnmarshal
-	} else {
-		rk := rt.Kind()
-		if fastpathEnabled && checkFastpath && (rk == reflect.Map || rk == reflect.Slice) {
-			if rt.PkgPath() == "" {
-				if idx := fastpathAV.index(rtid); idx != -1 {
-					fn.f = fastpathAV[idx].decfn
-				}
-			} else {
-				// use mapping for underlying type if there
-				ok = false
-				var rtu reflect.Type
-				if rk == reflect.Map {
-					rtu = reflect.MapOf(rt.Key(), rt.Elem())
-				} else {
-					rtu = reflect.SliceOf(rt.Elem())
-				}
-				rtuid := rt2id(rtu)
-				if idx := fastpathAV.index(rtuid); idx != -1 {
-					xfnf := fastpathAV[idx].decfn
-					xrt := fastpathAV[idx].rt
-					fn.f = func(xf *decFnInfo, xrv reflect.Value) {
-						// xfnf(xf, xrv.Convert(xrt))
-						xfnf(xf, xrv.Addr().Convert(reflect.PtrTo(xrt)).Elem())
-					}
-				}
-			}
-		}
-		if fn.f == nil {
-			switch rk {
-			case reflect.String:
-				fn.f = (*decFnInfo).kString
-			case reflect.Bool:
-				fn.f = (*decFnInfo).kBool
-			case reflect.Int:
-				fn.f = (*decFnInfo).kInt
-			case reflect.Int64:
-				fn.f = (*decFnInfo).kInt64
-			case reflect.Int32:
-				fn.f = (*decFnInfo).kInt32
-			case reflect.Int8:
-				fn.f = (*decFnInfo).kInt8
-			case reflect.Int16:
-				fn.f = (*decFnInfo).kInt16
-			case reflect.Float32:
-				fn.f = (*decFnInfo).kFloat32
-			case reflect.Float64:
-				fn.f = (*decFnInfo).kFloat64
-			case reflect.Uint8:
-				fn.f = (*decFnInfo).kUint8
-			case reflect.Uint64:
-				fn.f = (*decFnInfo).kUint64
-			case reflect.Uint:
-				fn.f = (*decFnInfo).kUint
-			case reflect.Uint32:
-				fn.f = (*decFnInfo).kUint32
-			case reflect.Uint16:
-				fn.f = (*decFnInfo).kUint16
-				// case reflect.Ptr:
-				// 	fn.f = (*decFnInfo).kPtr
-			case reflect.Uintptr:
-				fn.f = (*decFnInfo).kUintptr
-			case reflect.Interface:
-				fn.f = (*decFnInfo).kInterface
-			case reflect.Struct:
-				fn.f = (*decFnInfo).kStruct
-			case reflect.Chan:
-				fi.seq = seqTypeChan
-				fn.f = (*decFnInfo).kSlice
-			case reflect.Slice:
-				fi.seq = seqTypeSlice
-				fn.f = (*decFnInfo).kSlice
-			case reflect.Array:
-				fi.seq = seqTypeArray
-				fn.f = (*decFnInfo).kArray
-			case reflect.Map:
-				fn.f = (*decFnInfo).kMap
-			default:
-				fn.f = (*decFnInfo).kErr
-			}
-		}
-	}
-
-	return
+	// return rv
 }
 
 func (d *Decoder) structFieldNotFound(index int, rvkencname string) {
@@ -1838,17 +2266,35 @@ func (d *Decoder) arrayCannotExpand(sliceLen, streamLen int) {
 	}
 }
 
-func (d *Decoder) chkPtrValue(rv reflect.Value) {
-	// We can only decode into a non-nil pointer
-	if rv.Kind() == reflect.Ptr && !rv.IsNil() {
-		return
+func isDecodeable(rv reflect.Value) (rv2 reflect.Value, canDecode bool) {
+	switch rv.Kind() {
+	case reflect.Array:
+		return rv, true
+	case reflect.Ptr:
+		if !rv.IsNil() {
+			return rv.Elem(), true
+		}
+	case reflect.Slice, reflect.Chan, reflect.Map:
+		if !rv.IsNil() {
+			return rv, true
+		}
 	}
-	d.errNotValidPtrValue(rv)
+	return
 }
 
-func (d *Decoder) errNotValidPtrValue(rv reflect.Value) {
+func (d *Decoder) ensureDecodeable(rv reflect.Value) (rv2 reflect.Value) {
+	// decode can take any reflect.Value that is a inherently addressable i.e.
+	//   - array
+	//   - non-nil chan    (we will SEND to it)
+	//   - non-nil slice   (we will set its elements)
+	//   - non-nil map     (we will put into it)
+	//   - non-nil pointer (we can "update" it)
+	rv2, canDecode := isDecodeable(rv)
+	if canDecode {
+		return
+	}
 	if !rv.IsValid() {
-		d.error(cannotDecodeIntoNilErr)
+		d.errorstr(errstrCannotDecodeIntoNil)
 		return
 	}
 	if !rv.CanInterface() {
@@ -1856,19 +2302,9 @@ func (d *Decoder) errNotValidPtrValue(rv reflect.Value) {
 		return
 	}
 	rvi := rv2i(rv)
-	d.errorf("cannot decode into non-pointer or nil pointer. Got: %v, %T, %v", rv.Kind(), rvi, rvi)
-}
-
-func (d *Decoder) error(err error) {
-	panic(err)
-}
-
-func (d *Decoder) errorf(format string, params ...interface{}) {
-	params2 := make([]interface{}, len(params)+1)
-	params2[0] = d.r.numread()
-	copy(params2[1:], params)
-	err := fmt.Errorf("[pos %d]: "+format, params2...)
-	panic(err)
+	rvk := rv.Kind()
+	d.errorf("cannot decode into value of kind: %v, type: %T, %v", rvk, rvi, rvi)
+	return
 }
 
 // Possibly get an interned version of a string
@@ -1887,21 +2323,16 @@ func (d *Decoder) string(v []byte) (s string) {
 	return s
 }
 
-// func (d *Decoder) intern(s string) {
-// 	if d.is != nil {
-// 		d.is[s] = s
-// 	}
-// }
-
 // nextValueBytes returns the next value in the stream as a set of bytes.
-func (d *Decoder) nextValueBytes() []byte {
+func (d *Decoder) nextValueBytes() (bs []byte) {
 	d.d.uncacheRead()
 	d.r.track()
 	d.swallow()
-	return d.r.stopTrack()
+	bs = d.r.stopTrack()
+	return
 }
 
-func (d *Decoder) raw() []byte {
+func (d *Decoder) rawBytes() []byte {
 	// ensure that this is not a view into the bytes
 	// i.e. make new copy always.
 	bs := d.nextValueBytes()
@@ -1910,6 +2341,10 @@ func (d *Decoder) raw() []byte {
 	return bs2
 }
 
+func (d *Decoder) wrapErrstr(v interface{}, err *error) {
+	*err = fmt.Errorf("%s decode error [pos %d]: %v", d.hh.Name(), d.r.numread(), v)
+}
+
 // --------------------------------------------------
 
 // decSliceHelper assists when decoding into a slice, from a map or an array in the stream.
@@ -1923,12 +2358,13 @@ type decSliceHelper struct {
 func (d *Decoder) decSliceHelperStart() (x decSliceHelper, clen int) {
 	dd := d.d
 	ctyp := dd.ContainerType()
-	if ctyp == valueTypeArray {
+	switch ctyp {
+	case valueTypeArray:
 		x.array = true
 		clen = dd.ReadArrayStart()
-	} else if ctyp == valueTypeMap {
+	case valueTypeMap:
 		clen = dd.ReadMapStart() * 2
-	} else {
+	default:
 		d.errorf("only encoded map or array can be decoded into a slice (%d)", ctyp)
 	}
 	// x.ct = ctyp
@@ -1937,30 +2373,20 @@ func (d *Decoder) decSliceHelperStart() (x decSliceHelper, clen int) {
 }
 
 func (x decSliceHelper) End() {
-	cr := x.d.cr
-	if cr == nil {
-		return
-	}
 	if x.array {
-		cr.sendContainerState(containerArrayEnd)
+		x.d.d.ReadArrayEnd()
 	} else {
-		cr.sendContainerState(containerMapEnd)
+		x.d.d.ReadMapEnd()
 	}
 }
 
 func (x decSliceHelper) ElemContainerState(index int) {
-	cr := x.d.cr
-	if cr == nil {
-		return
-	}
 	if x.array {
-		cr.sendContainerState(containerArrayElem)
+		x.d.d.ReadArrayElem()
+	} else if index%2 == 0 {
+		x.d.d.ReadMapElemKey()
 	} else {
-		if index%2 == 0 {
-			cr.sendContainerState(containerMapKey)
-		} else {
-			cr.sendContainerState(containerMapValue)
-		}
+		x.d.d.ReadMapElemValue()
 	}
 }
 
@@ -1981,7 +2407,6 @@ func decByteSlice(r decReader, clen, maxInitLen int, bs []byte) (bsOut []byte) {
 		r.readb(bsOut)
 		for len2 < clen {
 			len3 := decInferLen(clen-len2, maxInitLen, 1)
-			// fmt.Printf(">>>>> TESTING: in loop: clen: %v, maxInitLen: %v, len2: %v, len3: %v\n", clen, maxInitLen, len2, len3)
 			bs3 := bsOut
 			bsOut = make([]byte, len2+len3)
 			copy(bsOut, bs3)
@@ -2017,6 +2442,9 @@ func decInferLen(clen, maxlen, unit int) (rvlen int) {
 	if clen <= 0 {
 		return
 	}
+	if unit == 0 {
+		return clen
+	}
 	if maxlen <= 0 {
 		// no maxlen defined. Use maximum of 256K memory, with a floor of 4K items.
 		// maxlen = 256 * 1024 / unit
@@ -2035,59 +2463,53 @@ func decInferLen(clen, maxlen, unit int) (rvlen int) {
 		rvlen = clen
 	}
 	return
-	// if clen <= 0 {
-	// 	rvlen = 0
-	// } else if maxlen > 0 && clen > maxlen {
-	// 	rvlen = maxlen
-	// 	truncated = true
-	// } else {
-	// 	rvlen = clen
-	// }
-	// return
 }
 
-func decExpandSliceRV(s reflect.Value, st reflect.Type, stElemSize, num, slen, scap int) (
-	s2 reflect.Value, scap2 int, changed bool) {
-	// fmt.Printf("dec-expand-slice-rv: %v, %v\n", s, st)
+func expandSliceRV(s reflect.Value, st reflect.Type, canChange bool, stElemSize, num, slen, scap int) (
+	s2 reflect.Value, scap2 int, changed bool, err string) {
 	l1 := slen + num // new slice length
 	if l1 < slen {
-		panic("expandSlice: slice overflow")
+		err = errmsgExpandSliceOverflow
+		return
 	}
 	if l1 <= scap {
 		if s.CanSet() {
 			s.SetLen(l1)
-		} else {
+		} else if canChange {
 			s2 = s.Slice(0, l1)
 			scap2 = scap
 			changed = true
+		} else {
+			err = errmsgExpandSliceCannotChange
+			return
 		}
 		return
 	}
+	if !canChange {
+		err = errmsgExpandSliceCannotChange
+		return
+	}
 	scap2 = growCap(scap, stElemSize, num)
 	s2 = reflect.MakeSlice(st, l1, scap2)
 	changed = true
-	// println("expandslicevalue: cap-old: ", c0, ", cap-new: ", c1, ", len-new: ", l1)
 	reflect.Copy(s2, s)
 	return
 }
 
-// // implement overall decReader wrapping both, for possible use inline:
-// type decReaderT struct {
-// 	bytes bool
-// 	rb    *bytesDecReader
-// 	ri    *ioDecReader
-// }
-//
-// // implement *Decoder as a decReader.
-// // Using decReaderT (defined just above) caused performance degradation
-// // possibly because of constant copying the value,
-// // and some value->interface conversion causing allocation.
-// func (d *Decoder) unreadn1() {
-// 	if d.bytes {
-// 		d.rb.unreadn1()
-// 	} else {
-// 		d.ri.unreadn1()
-// 	}
-// }
-// ... for other methods of decReader.
-// Testing showed that performance improvement was negligible.
+func decReadFull(r io.Reader, bs []byte) (n int, err error) {
+	var nn int
+	for n < len(bs) && err == nil {
+		nn, err = r.Read(bs[n:])
+		if nn > 0 {
+			if err == io.EOF {
+				// leave EOF for next time
+				err = nil
+			}
+			n += nn
+		}
+	}
+
+	// do not do this - it serves no purpose
+	// if n != len(bs) && err == io.EOF { err = io.ErrUnexpectedEOF }
+	return
+}
diff --git a/vendor/github.com/ugorji/go/codec/encode.go b/vendor/github.com/ugorji/go/codec/encode.go
index a9fa72f92..ffaf59cd4 100644
--- a/vendor/github.com/ugorji/go/codec/encode.go
+++ b/vendor/github.com/ugorji/go/codec/encode.go
@@ -4,25 +4,27 @@
 package codec
 
 import (
+	"bufio"
 	"encoding"
+	"errors"
 	"fmt"
 	"io"
 	"reflect"
 	"sort"
+	"strconv"
 	"sync"
+	"time"
 )
 
-const (
-	defEncByteBufSize = 1 << 6 // 4:16, 6:64, 8:256, 10:1024
-)
+const defEncByteBufSize = 1 << 6 // 4:16, 6:64, 8:256, 10:1024
+
+var errEncoderNotInitialized = errors.New("Encoder not initialized")
 
 // AsSymbolFlag defines what should be encoded as symbols.
 type AsSymbolFlag uint8
 
 const (
-	// AsSymbolDefault is default.
-	// Currently, this means only encode struct field names as symbols.
-	// The default is subject to change.
+	// AsSymbolDefault means only encode struct field names as symbols.
 	AsSymbolDefault AsSymbolFlag = iota
 
 	// AsSymbolAll means encode anything which could be a symbol as a symbol.
@@ -31,10 +33,10 @@ const (
 	// AsSymbolNone means do not encode anything as a symbol.
 	AsSymbolNone = 1 << iota
 
-	// AsSymbolMapStringKeys means encode keys in map[string]XXX as symbols.
+	// AsSymbolMapStringKeysFlag means encode keys in map[string]XXX as symbols.
 	AsSymbolMapStringKeysFlag
 
-	// AsSymbolStructFieldName means encode struct field names as symbols.
+	// AsSymbolStructFieldNameFlag means encode struct field names as symbols.
 	AsSymbolStructFieldNameFlag
 )
 
@@ -49,8 +51,11 @@ type encWriter interface {
 
 // encDriver abstracts the actual codec (binc vs msgpack, etc)
 type encDriver interface {
-	IsBuiltinType(rt uintptr) bool
+	// IsBuiltinType(rt uintptr) bool
+
+	// Deprecated: left here for now so that old codecgen'ed filed will work. TODO: remove.
 	EncodeBuiltin(rt uintptr, v interface{})
+
 	EncodeNil()
 	EncodeInt(i int64)
 	EncodeUint(i uint64)
@@ -60,36 +65,51 @@ type encDriver interface {
 	// encodeExtPreamble(xtag byte, length int)
 	EncodeRawExt(re *RawExt, e *Encoder)
 	EncodeExt(v interface{}, xtag uint64, ext Ext, e *Encoder)
-	EncodeArrayStart(length int)
-	EncodeMapStart(length int)
+	WriteArrayStart(length int)
+	WriteArrayElem()
+	WriteArrayEnd()
+	WriteMapStart(length int)
+	WriteMapElemKey()
+	WriteMapElemValue()
+	WriteMapEnd()
 	EncodeString(c charEncoding, v string)
 	EncodeSymbol(v string)
 	EncodeStringBytes(c charEncoding, v []byte)
+	EncodeTime(time.Time)
 	//TODO
 	//encBignum(f *big.Int)
 	//encStringRunes(c charEncoding, v []rune)
 
 	reset()
-}
-
-type encDriverAsis interface {
-	EncodeAsis(v []byte)
-}
-
-type encNoSeparator struct{}
-
-func (_ encNoSeparator) EncodeEnd() {}
-
-type ioEncWriterWriter interface {
-	WriteByte(c byte) error
-	WriteString(s string) (n int, err error)
-	Write(p []byte) (n int, err error)
+	atEndOfEncode()
 }
 
 type ioEncStringWriter interface {
 	WriteString(s string) (n int, err error)
 }
 
+type encDriverAsis interface {
+	EncodeAsis(v []byte)
+}
+
+type encDriverNoopContainerWriter struct{}
+
+func (encDriverNoopContainerWriter) WriteArrayStart(length int) {}
+func (encDriverNoopContainerWriter) WriteArrayElem()            {}
+func (encDriverNoopContainerWriter) WriteArrayEnd()             {}
+func (encDriverNoopContainerWriter) WriteMapStart(length int)   {}
+func (encDriverNoopContainerWriter) WriteMapElemKey()           {}
+func (encDriverNoopContainerWriter) WriteMapElemValue()         {}
+func (encDriverNoopContainerWriter) WriteMapEnd()               {}
+func (encDriverNoopContainerWriter) atEndOfEncode()             {}
+
+// type ioEncWriterWriter interface {
+// 	WriteByte(c byte) error
+// 	WriteString(s string) (n int, err error)
+// 	Write(p []byte) (n int, err error)
+// }
+
+// EncodeOptions captures configuration options during encode.
 type EncodeOptions struct {
 	// Encode a struct as an array, and not as a map
 	StructToArray bool
@@ -146,316 +166,212 @@ type EncodeOptions struct {
 	//   AsSymbolMapStringKeys
 	//   AsSymbolMapStringKeysFlag | AsSymbolStructFieldNameFlag
 	AsSymbols AsSymbolFlag
+
+	// WriterBufferSize is the size of the buffer used when writing.
+	//
+	// if > 0, we use a smart buffer internally for performance purposes.
+	WriterBufferSize int
 }
 
 // ---------------------------------------------
 
-type simpleIoEncWriterWriter struct {
-	w  io.Writer
-	bw io.ByteWriter
-	sw ioEncStringWriter
-	bs [1]byte
+type simpleIoEncWriter struct {
+	io.Writer
 }
 
-func (o *simpleIoEncWriterWriter) WriteByte(c byte) (err error) {
-	if o.bw != nil {
-		return o.bw.WriteByte(c)
-	}
-	// _, err = o.w.Write([]byte{c})
-	o.bs[0] = c
-	_, err = o.w.Write(o.bs[:])
-	return
-}
-
-func (o *simpleIoEncWriterWriter) WriteString(s string) (n int, err error) {
-	if o.sw != nil {
-		return o.sw.WriteString(s)
-	}
-	// return o.w.Write([]byte(s))
-	return o.w.Write(bytesView(s))
-}
-
-func (o *simpleIoEncWriterWriter) Write(p []byte) (n int, err error) {
-	return o.w.Write(p)
-}
-
-// ----------------------------------------
-
 // ioEncWriter implements encWriter and can write to an io.Writer implementation
 type ioEncWriter struct {
-	w ioEncWriterWriter
-	s simpleIoEncWriterWriter
-	// x [8]byte // temp byte array re-used internally for efficiency
+	w  io.Writer
+	ww io.Writer
+	bw io.ByteWriter
+	sw ioEncStringWriter
+	fw ioFlusher
+	b  [8]byte
+}
+
+func (z *ioEncWriter) WriteByte(b byte) (err error) {
+	// x.bs[0] = b
+	// _, err = x.ww.Write(x.bs[:])
+	z.b[0] = b
+	_, err = z.w.Write(z.b[:1])
+	return
+}
+
+func (z *ioEncWriter) WriteString(s string) (n int, err error) {
+	return z.w.Write(bytesView(s))
 }
 
 func (z *ioEncWriter) writeb(bs []byte) {
-	if len(bs) == 0 {
-		return
-	}
-	n, err := z.w.Write(bs)
-	if err != nil {
+	// if len(bs) == 0 {
+	// 	return
+	// }
+	if _, err := z.ww.Write(bs); err != nil {
 		panic(err)
 	}
-	if n != len(bs) {
-		panic(fmt.Errorf("incorrect num bytes written. Expecting: %v, Wrote: %v", len(bs), n))
-	}
 }
 
 func (z *ioEncWriter) writestr(s string) {
-	n, err := z.w.WriteString(s)
-	if err != nil {
+	// if len(s) == 0 {
+	// 	return
+	// }
+	if _, err := z.sw.WriteString(s); err != nil {
 		panic(err)
 	}
-	if n != len(s) {
-		panic(fmt.Errorf("incorrect num bytes written. Expecting: %v, Wrote: %v", len(s), n))
-	}
 }
 
 func (z *ioEncWriter) writen1(b byte) {
-	if err := z.w.WriteByte(b); err != nil {
+	if err := z.bw.WriteByte(b); err != nil {
 		panic(err)
 	}
 }
 
-func (z *ioEncWriter) writen2(b1 byte, b2 byte) {
-	z.writen1(b1)
-	z.writen1(b2)
-}
-
-func (z *ioEncWriter) atEndOfEncode() {}
-
-// ----------------------------------------
-
-// bytesEncWriter implements encWriter and can write to an byte slice.
-// It is used by Marshal function.
-type bytesEncWriter struct {
-	b   []byte
-	c   int     // cursor
-	out *[]byte // write out on atEndOfEncode
-}
-
-func (z *bytesEncWriter) writeb(s []byte) {
-	if len(s) == 0 {
-		return
-	}
-	oc, a := z.growNoAlloc(len(s))
-	if a {
-		z.growAlloc(len(s), oc)
-	}
-	copy(z.b[oc:], s)
-}
-
-func (z *bytesEncWriter) writestr(s string) {
-	if len(s) == 0 {
-		return
-	}
-	oc, a := z.growNoAlloc(len(s))
-	if a {
-		z.growAlloc(len(s), oc)
-	}
-	copy(z.b[oc:], s)
-}
-
-func (z *bytesEncWriter) writen1(b1 byte) {
-	oc, a := z.growNoAlloc(1)
-	if a {
-		z.growAlloc(1, oc)
-	}
-	z.b[oc] = b1
-}
-
-func (z *bytesEncWriter) writen2(b1 byte, b2 byte) {
-	oc, a := z.growNoAlloc(2)
-	if a {
-		z.growAlloc(2, oc)
-	}
-	z.b[oc+1] = b2
-	z.b[oc] = b1
-}
-
-func (z *bytesEncWriter) atEndOfEncode() {
-	*(z.out) = z.b[:z.c]
-}
-
-// have a growNoalloc(n int), which can be inlined.
-// if allocation is needed, then call growAlloc(n int)
-
-func (z *bytesEncWriter) growNoAlloc(n int) (oldcursor int, allocNeeded bool) {
-	oldcursor = z.c
-	z.c = z.c + n
-	if z.c > len(z.b) {
-		if z.c > cap(z.b) {
-			allocNeeded = true
-		} else {
-			z.b = z.b[:cap(z.b)]
+func (z *ioEncWriter) writen2(b1, b2 byte) {
+	var err error
+	if err = z.bw.WriteByte(b1); err == nil {
+		if err = z.bw.WriteByte(b2); err == nil {
+			return
 		}
 	}
-	return
+	panic(err)
 }
 
-func (z *bytesEncWriter) growAlloc(n int, oldcursor int) {
-	// appendslice logic (if cap < 1024, *2, else *1.25): more expensive. many copy calls.
-	// bytes.Buffer model (2*cap + n): much better
-	// bs := make([]byte, 2*cap(z.b)+n)
-	bs := make([]byte, growCap(cap(z.b), 1, n))
-	copy(bs, z.b[:oldcursor])
-	z.b = bs
+// func (z *ioEncWriter) writen5(b1, b2, b3, b4, b5 byte) {
+// 	z.b[0], z.b[1], z.b[2], z.b[3], z.b[4] = b1, b2, b3, b4, b5
+// 	if _, err := z.ww.Write(z.b[:5]); err != nil {
+// 		panic(err)
+// 	}
+// }
+
+func (z *ioEncWriter) atEndOfEncode() {
+	if z.fw != nil {
+		z.fw.Flush()
+	}
 }
 
 // ---------------------------------------------
 
-type encFnInfo struct {
-	e     *Encoder
-	ti    *typeInfo
-	xfFn  Ext
-	xfTag uint64
-	seq   seqType
+// bytesEncAppender implements encWriter and can write to an byte slice.
+type bytesEncAppender struct {
+	b   []byte
+	out *[]byte
 }
 
-func (f *encFnInfo) builtin(rv reflect.Value) {
-	f.e.e.EncodeBuiltin(f.ti.rtid, rv2i(rv))
+func (z *bytesEncAppender) writeb(s []byte) {
+	z.b = append(z.b, s...)
+}
+func (z *bytesEncAppender) writestr(s string) {
+	z.b = append(z.b, s...)
+}
+func (z *bytesEncAppender) writen1(b1 byte) {
+	z.b = append(z.b, b1)
+}
+func (z *bytesEncAppender) writen2(b1, b2 byte) {
+	z.b = append(z.b, b1, b2)
+}
+func (z *bytesEncAppender) atEndOfEncode() {
+	*(z.out) = z.b
+}
+func (z *bytesEncAppender) reset(in []byte, out *[]byte) {
+	z.b = in[:0]
+	z.out = out
 }
 
-func (f *encFnInfo) raw(rv reflect.Value) {
-	f.e.raw(rv2i(rv).(Raw))
+// ---------------------------------------------
+
+// func (e *Encoder) builtin(f *codecFnInfo, rv reflect.Value) {
+// 	e.e.EncodeBuiltin(f.ti.rtid, rv2i(rv))
+// }
+
+func (e *Encoder) rawExt(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeRawExt(rv2i(rv).(*RawExt), e)
 }
 
-func (f *encFnInfo) rawExt(rv reflect.Value) {
-	// rev := rv2i(rv).(RawExt)
-	// f.e.e.EncodeRawExt(&rev, f.e)
-	var re *RawExt
-	if rv.CanAddr() {
-		re = rv2i(rv.Addr()).(*RawExt)
-	} else {
-		rev := rv2i(rv).(RawExt)
-		re = &rev
-	}
-	f.e.e.EncodeRawExt(re, f.e)
-}
-
-func (f *encFnInfo) ext(rv reflect.Value) {
+func (e *Encoder) ext(f *codecFnInfo, rv reflect.Value) {
 	// if this is a struct|array and it was addressable, then pass the address directly (not the value)
-	if k := rv.Kind(); (k == reflect.Struct || k == reflect.Array) && rv.CanAddr() {
-		rv = rv.Addr()
-	}
-	f.e.e.EncodeExt(rv2i(rv), f.xfTag, f.xfFn, f.e)
+	// if k := rv.Kind(); (k == reflect.Struct || k == reflect.Array) && rv.CanAddr() {
+	// 	rv = rv.Addr()
+	// }
+	e.e.EncodeExt(rv2i(rv), f.xfTag, f.xfFn, e)
 }
 
-func (f *encFnInfo) getValueForMarshalInterface(rv reflect.Value, indir int8) (v interface{}, proceed bool) {
-	if indir == 0 {
-		v = rv2i(rv)
-	} else if indir == -1 {
-		// If a non-pointer was passed to Encode(), then that value is not addressable.
-		// Take addr if addressable, else copy value to an addressable value.
-		if rv.CanAddr() {
-			v = rv2i(rv.Addr())
-		} else {
-			rv2 := reflect.New(rv.Type())
-			rv2.Elem().Set(rv)
-			v = rv2i(rv2)
-			// fmt.Printf("rv.Type: %v, rv2.Type: %v, v: %v\n", rv.Type(), rv2.Type(), v)
-		}
-	} else {
-		for j := int8(0); j < indir; j++ {
-			if rv.IsNil() {
-				f.e.e.EncodeNil()
-				return
-			}
-			rv = rv.Elem()
-		}
-		v = rv2i(rv)
-	}
-	return v, true
+// func rviptr(rv reflect.Value) (v interface{}) {
+// 	// If a non-pointer was passed to Encode(), then that value is not addressable.
+// 	// Take addr if addressable, else copy value to an addressable value.
+// 	if rv.CanAddr() {
+// 		v = rv2i(rv.Addr())
+// 	} else {
+// 		rv2 := reflect.New(rv.Type())
+// 		rv2.Elem().Set(rv)
+// 		v = rv2i(rv2)
+// 	}
+// 	return v
+// }
+
+func (e *Encoder) selferMarshal(f *codecFnInfo, rv reflect.Value) {
+	rv2i(rv).(Selfer).CodecEncodeSelf(e)
 }
 
-func (f *encFnInfo) selferMarshal(rv reflect.Value) {
-	if v, proceed := f.getValueForMarshalInterface(rv, f.ti.csIndir); proceed {
-		v.(Selfer).CodecEncodeSelf(f.e)
-	}
+func (e *Encoder) binaryMarshal(f *codecFnInfo, rv reflect.Value) {
+	bs, fnerr := rv2i(rv).(encoding.BinaryMarshaler).MarshalBinary()
+	e.marshal(bs, fnerr, false, cRAW)
 }
 
-func (f *encFnInfo) binaryMarshal(rv reflect.Value) {
-	if v, proceed := f.getValueForMarshalInterface(rv, f.ti.bmIndir); proceed {
-		bs, fnerr := v.(encoding.BinaryMarshaler).MarshalBinary()
-		f.e.marshal(bs, fnerr, false, c_RAW)
-	}
+func (e *Encoder) textMarshal(f *codecFnInfo, rv reflect.Value) {
+	bs, fnerr := rv2i(rv).(encoding.TextMarshaler).MarshalText()
+	e.marshal(bs, fnerr, false, cUTF8)
 }
 
-func (f *encFnInfo) textMarshal(rv reflect.Value) {
-	if v, proceed := f.getValueForMarshalInterface(rv, f.ti.tmIndir); proceed {
-		// debugf(">>>> encoding.TextMarshaler: %T", rv2i(rv))
-		bs, fnerr := v.(encoding.TextMarshaler).MarshalText()
-		f.e.marshal(bs, fnerr, false, c_UTF8)
-	}
+func (e *Encoder) jsonMarshal(f *codecFnInfo, rv reflect.Value) {
+	bs, fnerr := rv2i(rv).(jsonMarshaler).MarshalJSON()
+	e.marshal(bs, fnerr, true, cUTF8)
 }
 
-func (f *encFnInfo) jsonMarshal(rv reflect.Value) {
-	if v, proceed := f.getValueForMarshalInterface(rv, f.ti.jmIndir); proceed {
-		bs, fnerr := v.(jsonMarshaler).MarshalJSON()
-		f.e.marshal(bs, fnerr, true, c_UTF8)
-	}
+func (e *Encoder) raw(f *codecFnInfo, rv reflect.Value) {
+	e.rawBytes(rv2i(rv).(Raw))
 }
 
-func (f *encFnInfo) kBool(rv reflect.Value) {
-	f.e.e.EncodeBool(rv.Bool())
+func (e *Encoder) kInvalid(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeNil()
 }
 
-func (f *encFnInfo) kString(rv reflect.Value) {
-	f.e.e.EncodeString(c_UTF8, rv.String())
+func (e *Encoder) kErr(f *codecFnInfo, rv reflect.Value) {
+	e.errorf("unsupported kind %s, for %#v", rv.Kind(), rv)
 }
 
-func (f *encFnInfo) kFloat64(rv reflect.Value) {
-	f.e.e.EncodeFloat64(rv.Float())
-}
-
-func (f *encFnInfo) kFloat32(rv reflect.Value) {
-	f.e.e.EncodeFloat32(float32(rv.Float()))
-}
-
-func (f *encFnInfo) kInt(rv reflect.Value) {
-	f.e.e.EncodeInt(rv.Int())
-}
-
-func (f *encFnInfo) kUint(rv reflect.Value) {
-	f.e.e.EncodeUint(rv.Uint())
-}
-
-func (f *encFnInfo) kInvalid(rv reflect.Value) {
-	f.e.e.EncodeNil()
-}
-
-func (f *encFnInfo) kErr(rv reflect.Value) {
-	f.e.errorf("unsupported kind %s, for %#v", rv.Kind(), rv)
-}
-
-func (f *encFnInfo) kSlice(rv reflect.Value) {
+func (e *Encoder) kSlice(f *codecFnInfo, rv reflect.Value) {
 	ti := f.ti
+	ee := e.e
 	// array may be non-addressable, so we have to manage with care
 	//   (don't call rv.Bytes, rv.Slice, etc).
 	// E.g. type struct S{B [2]byte};
 	//   Encode(S{}) will bomb on "panic: slice of unaddressable array".
-	e := f.e
 	if f.seq != seqTypeArray {
 		if rv.IsNil() {
-			e.e.EncodeNil()
+			ee.EncodeNil()
 			return
 		}
 		// If in this method, then there was no extension function defined.
 		// So it's okay to treat as []byte.
 		if ti.rtid == uint8SliceTypId {
-			e.e.EncodeStringBytes(c_RAW, rv.Bytes())
+			ee.EncodeStringBytes(cRAW, rv.Bytes())
 			return
 		}
 	}
-	cr := e.cr
-	rtelem := ti.rt.Elem()
+	if f.seq == seqTypeChan && ti.rt.ChanDir()&reflect.RecvDir == 0 {
+		e.errorf("send-only channel cannot be used for receiving byte(s)")
+	}
+	elemsep := e.esep
 	l := rv.Len()
-	if ti.rtid == uint8SliceTypId || rtelem.Kind() == reflect.Uint8 {
+	rtelem := ti.rt.Elem()
+	rtelemIsByte := uint8TypId == rt2id(rtelem) // NOT rtelem.Kind() == reflect.Uint8
+	// if a slice, array or chan of bytes, treat specially
+	if rtelemIsByte {
 		switch f.seq {
+		case seqTypeSlice:
+			ee.EncodeStringBytes(cRAW, rv.Bytes())
 		case seqTypeArray:
-			// if l == 0 { e.e.encodeStringBytes(c_RAW, nil) } else
 			if rv.CanAddr() {
-				e.e.EncodeStringBytes(c_RAW, rv.Slice(0, l).Bytes())
+				ee.EncodeStringBytes(cRAW, rv.Slice(0, l).Bytes())
 			} else {
 				var bs []byte
 				if l <= cap(e.b) {
@@ -464,26 +380,23 @@ func (f *encFnInfo) kSlice(rv reflect.Value) {
 					bs = make([]byte, l)
 				}
 				reflect.Copy(reflect.ValueOf(bs), rv)
-				// TODO: Test that reflect.Copy works instead of manual one-by-one
-				// for i := 0; i < l; i++ {
-				// 	bs[i] = byte(rv.Index(i).Uint())
-				// }
-				e.e.EncodeStringBytes(c_RAW, bs)
+				ee.EncodeStringBytes(cRAW, bs)
 			}
-		case seqTypeSlice:
-			e.e.EncodeStringBytes(c_RAW, rv.Bytes())
 		case seqTypeChan:
 			bs := e.b[:0]
 			// do not use range, so that the number of elements encoded
 			// does not change, and encoding does not hang waiting on someone to close chan.
-			// for b := range rv2i(rv).(<-chan byte) {
-			// 	bs = append(bs, b)
-			// }
-			ch := rv2i(rv).(<-chan byte)
+			// for b := range rv2i(rv).(<-chan byte) { bs = append(bs, b) }
+			// ch := rv2i(rv).(<-chan byte) // fix error - that this is a chan byte, not a <-chan byte.
+			irv := rv2i(rv)
+			ch, ok := irv.(<-chan byte)
+			if !ok {
+				ch = irv.(chan byte)
+			}
 			for i := 0; i < l; i++ {
 				bs = append(bs, <-ch)
 			}
-			e.e.EncodeStringBytes(c_RAW, bs)
+			ee.EncodeStringBytes(cRAW, bs)
 		}
 		return
 	}
@@ -493,78 +406,176 @@ func (f *encFnInfo) kSlice(rv reflect.Value) {
 			e.errorf("mapBySlice requires even slice length, but got %v", l)
 			return
 		}
-		e.e.EncodeMapStart(l / 2)
+		ee.WriteMapStart(l / 2)
 	} else {
-		e.e.EncodeArrayStart(l)
+		ee.WriteArrayStart(l)
 	}
 
 	if l > 0 {
+		var fn *codecFn
 		for rtelem.Kind() == reflect.Ptr {
 			rtelem = rtelem.Elem()
 		}
 		// if kind is reflect.Interface, do not pre-determine the
 		// encoding type, because preEncodeValue may break it down to
 		// a concrete type and kInterface will bomb.
-		var fn *encFn
 		if rtelem.Kind() != reflect.Interface {
-			rtelemid := rt2id(rtelem)
-			fn = e.getEncFn(rtelemid, rtelem, true, true)
+			fn = e.cf.get(rtelem, true, true)
 		}
 		// TODO: Consider perf implication of encoding odd index values as symbols if type is string
 		for j := 0; j < l; j++ {
-			if cr != nil {
+			if elemsep {
 				if ti.mbs {
 					if j%2 == 0 {
-						cr.sendContainerState(containerMapKey)
+						ee.WriteMapElemKey()
 					} else {
-						cr.sendContainerState(containerMapValue)
+						ee.WriteMapElemValue()
 					}
 				} else {
-					cr.sendContainerState(containerArrayElem)
+					ee.WriteArrayElem()
 				}
 			}
 			if f.seq == seqTypeChan {
 				if rv2, ok2 := rv.Recv(); ok2 {
-					e.encodeValue(rv2, fn)
+					e.encodeValue(rv2, fn, true)
 				} else {
-					e.encode(nil) // WE HAVE TO DO SOMETHING, so nil if nothing received.
+					ee.EncodeNil() // WE HAVE TO DO SOMETHING, so nil if nothing received.
 				}
 			} else {
-				e.encodeValue(rv.Index(j), fn)
+				e.encodeValue(rv.Index(j), fn, true)
 			}
 		}
 	}
 
-	if cr != nil {
-		if ti.mbs {
-			cr.sendContainerState(containerMapEnd)
+	if ti.mbs {
+		ee.WriteMapEnd()
+	} else {
+		ee.WriteArrayEnd()
+	}
+}
+
+func (e *Encoder) kStructNoOmitempty(f *codecFnInfo, rv reflect.Value) {
+	fti := f.ti
+	elemsep := e.esep
+	tisfi := fti.sfip
+	toMap := !(fti.toArray || e.h.StructToArray)
+	if toMap {
+		tisfi = fti.sfi
+	}
+	ee := e.e
+
+	sfn := structFieldNode{v: rv, update: false}
+	if toMap {
+		ee.WriteMapStart(len(tisfi))
+		// asSymbols := e.h.AsSymbols&AsSymbolStructFieldNameFlag != 0
+		asSymbols := e.h.AsSymbols == AsSymbolDefault || e.h.AsSymbols&AsSymbolStructFieldNameFlag != 0
+		if elemsep {
+			for _, si := range tisfi {
+				ee.WriteMapElemKey()
+				encStructFieldKey(ee, fti.keyType, si.encName, asSymbols)
+				ee.WriteMapElemValue()
+				e.encodeValue(sfn.field(si), nil, true)
+			}
 		} else {
-			cr.sendContainerState(containerArrayEnd)
+			for _, si := range tisfi {
+				encStructFieldKey(ee, fti.keyType, si.encName, asSymbols)
+				e.encodeValue(sfn.field(si), nil, true)
+			}
+		}
+		ee.WriteMapEnd()
+	} else {
+		ee.WriteArrayStart(len(tisfi))
+		if elemsep {
+			for _, si := range tisfi {
+				ee.WriteArrayElem()
+				e.encodeValue(sfn.field(si), nil, true)
+			}
+		} else {
+			for _, si := range tisfi {
+				e.encodeValue(sfn.field(si), nil, true)
+			}
+		}
+		ee.WriteArrayEnd()
+	}
+}
+
+func encStructFieldKey(ee encDriver, keyType valueType, s string, asSymbols bool) {
+	var m must
+	switch keyType {
+	case valueTypeString:
+		if asSymbols {
+			ee.EncodeSymbol(s)
+		} else {
+			ee.EncodeString(cUTF8, s)
+		}
+	case valueTypeInt:
+		ee.EncodeInt(m.Int(strconv.ParseInt(s, 10, 64)))
+	case valueTypeUint:
+		ee.EncodeUint(m.Uint(strconv.ParseUint(s, 10, 64)))
+	case valueTypeFloat:
+		ee.EncodeFloat64(m.Float(strconv.ParseFloat(s, 64)))
+	default: // string
+		if asSymbols {
+			ee.EncodeSymbol(s)
+		} else {
+			ee.EncodeString(cUTF8, s)
 		}
 	}
 }
 
-func (f *encFnInfo) kStruct(rv reflect.Value) {
+func (e *Encoder) kStruct(f *codecFnInfo, rv reflect.Value) {
 	fti := f.ti
-	e := f.e
-	cr := e.cr
+	elemsep := e.esep
 	tisfi := fti.sfip
 	toMap := !(fti.toArray || e.h.StructToArray)
-	newlen := len(fti.sfi)
-
-	// Use sync.Pool to reduce allocating slices unnecessarily.
-	// The cost of sync.Pool is less than the cost of new allocation.
-	pool, poolv, fkvs := encStructPoolGet(newlen)
-
 	// if toMap, use the sorted array. If toArray, use unsorted array (to match sequence in struct)
 	if toMap {
 		tisfi = fti.sfi
 	}
+	newlen := len(fti.sfi)
+	ee := e.e
+
+	// Use sync.Pool to reduce allocating slices unnecessarily.
+	// The cost of sync.Pool is less than the cost of new allocation.
+	//
+	// Each element of the array pools one of encStructPool(8|16|32|64).
+	// It allows the re-use of slices up to 64 in length.
+	// A performance cost of encoding structs was collecting
+	// which values were empty and should be omitted.
+	// We needed slices of reflect.Value and string to collect them.
+	// This shared pool reduces the amount of unnecessary creation we do.
+	// The cost is that of locking sometimes, but sync.Pool is efficient
+	// enough to reduce thread contention.
+
+	var spool *sync.Pool
+	var poolv interface{}
+	var fkvs []stringRv
+	if newlen <= 8 {
+		spool, poolv = pool.stringRv8()
+		fkvs = poolv.(*[8]stringRv)[:newlen]
+	} else if newlen <= 16 {
+		spool, poolv = pool.stringRv16()
+		fkvs = poolv.(*[16]stringRv)[:newlen]
+	} else if newlen <= 32 {
+		spool, poolv = pool.stringRv32()
+		fkvs = poolv.(*[32]stringRv)[:newlen]
+	} else if newlen <= 64 {
+		spool, poolv = pool.stringRv64()
+		fkvs = poolv.(*[64]stringRv)[:newlen]
+	} else if newlen <= 128 {
+		spool, poolv = pool.stringRv128()
+		fkvs = poolv.(*[128]stringRv)[:newlen]
+	} else {
+		fkvs = make([]stringRv, newlen)
+	}
+
 	newlen = 0
 	var kv stringRv
 	recur := e.h.RecursiveEmptyCheck
+	sfn := structFieldNode{v: rv, update: false}
 	for _, si := range tisfi {
-		kv.r = si.field(rv, false)
+		// kv.r = si.field(rv, false)
+		kv.r = sfn.field(si)
 		if toMap {
 			if si.omitEmpty && isEmptyValue(kv.r, recur, recur) {
 				continue
@@ -584,88 +595,61 @@ func (f *encFnInfo) kStruct(rv reflect.Value) {
 		newlen++
 	}
 
-	// debugf(">>>> kStruct: newlen: %v", newlen)
-	// sep := !e.be
-	ee := e.e //don't dereference every time
-
 	if toMap {
-		ee.EncodeMapStart(newlen)
+		ee.WriteMapStart(newlen)
 		// asSymbols := e.h.AsSymbols&AsSymbolStructFieldNameFlag != 0
 		asSymbols := e.h.AsSymbols == AsSymbolDefault || e.h.AsSymbols&AsSymbolStructFieldNameFlag != 0
-		for j := 0; j < newlen; j++ {
-			kv = fkvs[j]
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if elemsep {
+			for j := 0; j < newlen; j++ {
+				kv = fkvs[j]
+				ee.WriteMapElemKey()
+				encStructFieldKey(ee, fti.keyType, kv.v, asSymbols)
+				ee.WriteMapElemValue()
+				e.encodeValue(kv.r, nil, true)
 			}
-			if asSymbols {
-				ee.EncodeSymbol(kv.v)
-			} else {
-				ee.EncodeString(c_UTF8, kv.v)
+		} else {
+			for j := 0; j < newlen; j++ {
+				kv = fkvs[j]
+				encStructFieldKey(ee, fti.keyType, kv.v, asSymbols)
+				e.encodeValue(kv.r, nil, true)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			e.encodeValue(kv.r, nil)
-		}
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
 		}
+		ee.WriteMapEnd()
 	} else {
-		ee.EncodeArrayStart(newlen)
-		for j := 0; j < newlen; j++ {
-			kv = fkvs[j]
-			if cr != nil {
-				cr.sendContainerState(containerArrayElem)
+		ee.WriteArrayStart(newlen)
+		if elemsep {
+			for j := 0; j < newlen; j++ {
+				ee.WriteArrayElem()
+				e.encodeValue(fkvs[j].r, nil, true)
+			}
+		} else {
+			for j := 0; j < newlen; j++ {
+				e.encodeValue(fkvs[j].r, nil, true)
 			}
-			e.encodeValue(kv.r, nil)
-		}
-		if cr != nil {
-			cr.sendContainerState(containerArrayEnd)
 		}
+		ee.WriteArrayEnd()
 	}
 
 	// do not use defer. Instead, use explicit pool return at end of function.
 	// defer has a cost we are trying to avoid.
 	// If there is a panic and these slices are not returned, it is ok.
-	if pool != nil {
-		pool.Put(poolv)
+	if spool != nil {
+		spool.Put(poolv)
 	}
 }
 
-// func (f *encFnInfo) kPtr(rv reflect.Value) {
-// 	debugf(">>>>>>> ??? encode kPtr called - shouldn't get called")
-// 	if rv.IsNil() {
-// 		f.e.e.encodeNil()
-// 		return
-// 	}
-// 	f.e.encodeValue(rv.Elem())
-// }
-
-// func (f *encFnInfo) kInterface(rv reflect.Value) {
-// 	println("kInterface called")
-// 	debug.PrintStack()
-// 	if rv.IsNil() {
-// 		f.e.e.EncodeNil()
-// 		return
-// 	}
-// 	f.e.encodeValue(rv.Elem(), nil)
-// }
-
-func (f *encFnInfo) kMap(rv reflect.Value) {
-	ee := f.e.e
+func (e *Encoder) kMap(f *codecFnInfo, rv reflect.Value) {
+	ee := e.e
 	if rv.IsNil() {
 		ee.EncodeNil()
 		return
 	}
 
 	l := rv.Len()
-	ee.EncodeMapStart(l)
-	e := f.e
-	cr := e.cr
+	ee.WriteMapStart(l)
+	elemsep := e.esep
 	if l == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		ee.WriteMapEnd()
 		return
 	}
 	var asSymbols bool
@@ -676,13 +660,28 @@ func (f *encFnInfo) kMap(rv reflect.Value) {
 	// However, if kind is reflect.Interface, do not pre-determine the
 	// encoding type, because preEncodeValue may break it down to
 	// a concrete type and kInterface will bomb.
-	var keyFn, valFn *encFn
+	var keyFn, valFn *codecFn
 	ti := f.ti
-	rtkey := ti.rt.Key()
-	rtval := ti.rt.Elem()
-	rtkeyid := rt2id(rtkey)
-	// keyTypeIsString := f.ti.rt.Key().Kind() == reflect.String
-	var keyTypeIsString = rtkeyid == stringTypId
+	rtkey0 := ti.rt.Key()
+	rtkey := rtkey0
+	rtval0 := ti.rt.Elem()
+	rtval := rtval0
+	// rtkeyid := rt2id(rtkey0)
+	for rtval.Kind() == reflect.Ptr {
+		rtval = rtval.Elem()
+	}
+	if rtval.Kind() != reflect.Interface {
+		valFn = e.cf.get(rtval, true, true)
+	}
+	mks := rv.MapKeys()
+
+	if e.h.Canonical {
+		e.kMapCanonical(rtkey, rv, mks, valFn, asSymbols)
+		ee.WriteMapEnd()
+		return
+	}
+
+	var keyTypeIsString = stringTypId == rt2id(rtkey0) // rtkeyid
 	if keyTypeIsString {
 		asSymbols = e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	} else {
@@ -690,255 +689,299 @@ func (f *encFnInfo) kMap(rv reflect.Value) {
 			rtkey = rtkey.Elem()
 		}
 		if rtkey.Kind() != reflect.Interface {
-			rtkeyid = rt2id(rtkey)
-			keyFn = e.getEncFn(rtkeyid, rtkey, true, true)
+			// rtkeyid = rt2id(rtkey)
+			keyFn = e.cf.get(rtkey, true, true)
 		}
 	}
-	for rtval.Kind() == reflect.Ptr {
-		rtval = rtval.Elem()
-	}
-	if rtval.Kind() != reflect.Interface {
-		rtvalid := rt2id(rtval)
-		valFn = e.getEncFn(rtvalid, rtval, true, true)
-	}
-	mks := rv.MapKeys()
-	// for j, lmks := 0, len(mks); j < lmks; j++ {
 
-	if e.h.Canonical {
-		e.kMapCanonical(rtkeyid, rtkey, rv, mks, valFn, asSymbols)
-	} else {
-		for j := range mks {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			if keyTypeIsString {
-				if asSymbols {
-					ee.EncodeSymbol(mks[j].String())
-				} else {
-					ee.EncodeString(c_UTF8, mks[j].String())
-				}
-			} else {
-				e.encodeValue(mks[j], keyFn)
-			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			e.encodeValue(rv.MapIndex(mks[j]), valFn)
+	// for j, lmks := 0, len(mks); j < lmks; j++ {
+	for j := range mks {
+		if elemsep {
+			ee.WriteMapElemKey()
 		}
+		if keyTypeIsString {
+			if asSymbols {
+				ee.EncodeSymbol(mks[j].String())
+			} else {
+				ee.EncodeString(cUTF8, mks[j].String())
+			}
+		} else {
+			e.encodeValue(mks[j], keyFn, true)
+		}
+		if elemsep {
+			ee.WriteMapElemValue()
+		}
+		e.encodeValue(rv.MapIndex(mks[j]), valFn, true)
+
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (e *Encoder) kMapCanonical(rtkeyid uintptr, rtkey reflect.Type, rv reflect.Value, mks []reflect.Value, valFn *encFn, asSymbols bool) {
+func (e *Encoder) kMapCanonical(rtkey reflect.Type, rv reflect.Value, mks []reflect.Value, valFn *codecFn, asSymbols bool) {
 	ee := e.e
-	cr := e.cr
+	elemsep := e.esep
 	// we previously did out-of-band if an extension was registered.
 	// This is not necessary, as the natural kind is sufficient for ordering.
 
-	if rtkeyid == uint8SliceTypId {
-		mksv := make([]bytesRv, len(mks))
+	// WHAT IS THIS? rtkeyid can never be a []uint8, per spec
+	// if rtkeyid == uint8SliceTypId {
+	// 	mksv := make([]bytesRv, len(mks))
+	// 	for i, k := range mks {
+	// 		v := &mksv[i]
+	// 		v.r = k
+	// 		v.v = k.Bytes()
+	// 	}
+	// 	sort.Sort(bytesRvSlice(mksv))
+	// 	for i := range mksv {
+	// 		if elemsep {
+	// 			ee.WriteMapElemKey()
+	// 		}
+	// 		ee.EncodeStringBytes(cRAW, mksv[i].v)
+	// 		if elemsep {
+	// 			ee.WriteMapElemValue()
+	// 		}
+	// 		e.encodeValue(rv.MapIndex(mksv[i].r), valFn, true)
+	// 	}
+	// 	return
+	// }
+
+	switch rtkey.Kind() {
+	case reflect.Bool:
+		mksv := make([]boolRv, len(mks))
 		for i, k := range mks {
 			v := &mksv[i]
 			v.r = k
-			v.v = k.Bytes()
+			v.v = k.Bool()
 		}
-		sort.Sort(bytesRvSlice(mksv))
+		sort.Sort(boolRvSlice(mksv))
 		for i := range mksv {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if elemsep {
+				ee.WriteMapElemKey()
 			}
-			ee.EncodeStringBytes(c_RAW, mksv[i].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			ee.EncodeBool(mksv[i].v)
+			if elemsep {
+				ee.WriteMapElemValue()
 			}
-			e.encodeValue(rv.MapIndex(mksv[i].r), valFn)
+			e.encodeValue(rv.MapIndex(mksv[i].r), valFn, true)
 		}
-	} else {
-		switch rtkey.Kind() {
-		case reflect.Bool:
-			mksv := make([]boolRv, len(mks))
+	case reflect.String:
+		mksv := make([]stringRv, len(mks))
+		for i, k := range mks {
+			v := &mksv[i]
+			v.r = k
+			v.v = k.String()
+		}
+		sort.Sort(stringRvSlice(mksv))
+		for i := range mksv {
+			if elemsep {
+				ee.WriteMapElemKey()
+			}
+			if asSymbols {
+				ee.EncodeSymbol(mksv[i].v)
+			} else {
+				ee.EncodeString(cUTF8, mksv[i].v)
+			}
+			if elemsep {
+				ee.WriteMapElemValue()
+			}
+			e.encodeValue(rv.MapIndex(mksv[i].r), valFn, true)
+		}
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint, reflect.Uintptr:
+		mksv := make([]uintRv, len(mks))
+		for i, k := range mks {
+			v := &mksv[i]
+			v.r = k
+			v.v = k.Uint()
+		}
+		sort.Sort(uintRvSlice(mksv))
+		for i := range mksv {
+			if elemsep {
+				ee.WriteMapElemKey()
+			}
+			ee.EncodeUint(mksv[i].v)
+			if elemsep {
+				ee.WriteMapElemValue()
+			}
+			e.encodeValue(rv.MapIndex(mksv[i].r), valFn, true)
+		}
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		mksv := make([]intRv, len(mks))
+		for i, k := range mks {
+			v := &mksv[i]
+			v.r = k
+			v.v = k.Int()
+		}
+		sort.Sort(intRvSlice(mksv))
+		for i := range mksv {
+			if elemsep {
+				ee.WriteMapElemKey()
+			}
+			ee.EncodeInt(mksv[i].v)
+			if elemsep {
+				ee.WriteMapElemValue()
+			}
+			e.encodeValue(rv.MapIndex(mksv[i].r), valFn, true)
+		}
+	case reflect.Float32:
+		mksv := make([]floatRv, len(mks))
+		for i, k := range mks {
+			v := &mksv[i]
+			v.r = k
+			v.v = k.Float()
+		}
+		sort.Sort(floatRvSlice(mksv))
+		for i := range mksv {
+			if elemsep {
+				ee.WriteMapElemKey()
+			}
+			ee.EncodeFloat32(float32(mksv[i].v))
+			if elemsep {
+				ee.WriteMapElemValue()
+			}
+			e.encodeValue(rv.MapIndex(mksv[i].r), valFn, true)
+		}
+	case reflect.Float64:
+		mksv := make([]floatRv, len(mks))
+		for i, k := range mks {
+			v := &mksv[i]
+			v.r = k
+			v.v = k.Float()
+		}
+		sort.Sort(floatRvSlice(mksv))
+		for i := range mksv {
+			if elemsep {
+				ee.WriteMapElemKey()
+			}
+			ee.EncodeFloat64(mksv[i].v)
+			if elemsep {
+				ee.WriteMapElemValue()
+			}
+			e.encodeValue(rv.MapIndex(mksv[i].r), valFn, true)
+		}
+	case reflect.Struct:
+		if rv.Type() == timeTyp {
+			mksv := make([]timeRv, len(mks))
 			for i, k := range mks {
 				v := &mksv[i]
 				v.r = k
-				v.v = k.Bool()
+				v.v = rv2i(k).(time.Time)
 			}
-			sort.Sort(boolRvSlice(mksv))
+			sort.Sort(timeRvSlice(mksv))
 			for i := range mksv {
-				if cr != nil {
-					cr.sendContainerState(containerMapKey)
+				if elemsep {
+					ee.WriteMapElemKey()
 				}
-				ee.EncodeBool(mksv[i].v)
-				if cr != nil {
-					cr.sendContainerState(containerMapValue)
+				ee.EncodeTime(mksv[i].v)
+				if elemsep {
+					ee.WriteMapElemValue()
 				}
-				e.encodeValue(rv.MapIndex(mksv[i].r), valFn)
+				e.encodeValue(rv.MapIndex(mksv[i].r), valFn, true)
 			}
-		case reflect.String:
-			mksv := make([]stringRv, len(mks))
-			for i, k := range mks {
-				v := &mksv[i]
-				v.r = k
-				v.v = k.String()
+			break
+		}
+		fallthrough
+	default:
+		// out-of-band
+		// first encode each key to a []byte first, then sort them, then record
+		var mksv []byte = make([]byte, 0, len(mks)*16) // temporary byte slice for the encoding
+		e2 := NewEncoderBytes(&mksv, e.hh)
+		mksbv := make([]bytesRv, len(mks))
+		for i, k := range mks {
+			v := &mksbv[i]
+			l := len(mksv)
+			e2.MustEncode(k)
+			v.r = k
+			v.v = mksv[l:]
+		}
+		sort.Sort(bytesRvSlice(mksbv))
+		for j := range mksbv {
+			if elemsep {
+				ee.WriteMapElemKey()
 			}
-			sort.Sort(stringRvSlice(mksv))
-			for i := range mksv {
-				if cr != nil {
-					cr.sendContainerState(containerMapKey)
-				}
-				if asSymbols {
-					ee.EncodeSymbol(mksv[i].v)
-				} else {
-					ee.EncodeString(c_UTF8, mksv[i].v)
-				}
-				if cr != nil {
-					cr.sendContainerState(containerMapValue)
-				}
-				e.encodeValue(rv.MapIndex(mksv[i].r), valFn)
-			}
-		case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint, reflect.Uintptr:
-			mksv := make([]uintRv, len(mks))
-			for i, k := range mks {
-				v := &mksv[i]
-				v.r = k
-				v.v = k.Uint()
-			}
-			sort.Sort(uintRvSlice(mksv))
-			for i := range mksv {
-				if cr != nil {
-					cr.sendContainerState(containerMapKey)
-				}
-				ee.EncodeUint(mksv[i].v)
-				if cr != nil {
-					cr.sendContainerState(containerMapValue)
-				}
-				e.encodeValue(rv.MapIndex(mksv[i].r), valFn)
-			}
-		case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-			mksv := make([]intRv, len(mks))
-			for i, k := range mks {
-				v := &mksv[i]
-				v.r = k
-				v.v = k.Int()
-			}
-			sort.Sort(intRvSlice(mksv))
-			for i := range mksv {
-				if cr != nil {
-					cr.sendContainerState(containerMapKey)
-				}
-				ee.EncodeInt(mksv[i].v)
-				if cr != nil {
-					cr.sendContainerState(containerMapValue)
-				}
-				e.encodeValue(rv.MapIndex(mksv[i].r), valFn)
-			}
-		case reflect.Float32:
-			mksv := make([]floatRv, len(mks))
-			for i, k := range mks {
-				v := &mksv[i]
-				v.r = k
-				v.v = k.Float()
-			}
-			sort.Sort(floatRvSlice(mksv))
-			for i := range mksv {
-				if cr != nil {
-					cr.sendContainerState(containerMapKey)
-				}
-				ee.EncodeFloat32(float32(mksv[i].v))
-				if cr != nil {
-					cr.sendContainerState(containerMapValue)
-				}
-				e.encodeValue(rv.MapIndex(mksv[i].r), valFn)
-			}
-		case reflect.Float64:
-			mksv := make([]floatRv, len(mks))
-			for i, k := range mks {
-				v := &mksv[i]
-				v.r = k
-				v.v = k.Float()
-			}
-			sort.Sort(floatRvSlice(mksv))
-			for i := range mksv {
-				if cr != nil {
-					cr.sendContainerState(containerMapKey)
-				}
-				ee.EncodeFloat64(mksv[i].v)
-				if cr != nil {
-					cr.sendContainerState(containerMapValue)
-				}
-				e.encodeValue(rv.MapIndex(mksv[i].r), valFn)
-			}
-		default:
-			// out-of-band
-			// first encode each key to a []byte first, then sort them, then record
-			var mksv []byte = make([]byte, 0, len(mks)*16) // temporary byte slice for the encoding
-			e2 := NewEncoderBytes(&mksv, e.hh)
-			mksbv := make([]bytesRv, len(mks))
-			for i, k := range mks {
-				v := &mksbv[i]
-				l := len(mksv)
-				e2.MustEncode(k)
-				v.r = k
-				v.v = mksv[l:]
-				// fmt.Printf(">>>>> %s\n", mksv[l:])
-			}
-			sort.Sort(bytesRvSlice(mksbv))
-			for j := range mksbv {
-				if cr != nil {
-					cr.sendContainerState(containerMapKey)
-				}
-				e.asis(mksbv[j].v)
-				if cr != nil {
-					cr.sendContainerState(containerMapValue)
-				}
-				e.encodeValue(rv.MapIndex(mksbv[j].r), valFn)
+			e.asis(mksbv[j].v)
+			if elemsep {
+				ee.WriteMapElemValue()
 			}
+			e.encodeValue(rv.MapIndex(mksbv[j].r), valFn, true)
 		}
 	}
 }
 
-// --------------------------------------------------
+// // --------------------------------------------------
 
-// encFn encapsulates the captured variables and the encode function.
-// This way, we only do some calculations one times, and pass to the
-// code block that should be called (encapsulated in a function)
-// instead of executing the checks every time.
-type encFn struct {
-	i encFnInfo
-	f func(*encFnInfo, reflect.Value)
+type encWriterSwitch struct {
+	wi ioEncWriter
+	// ---- cpu cache line boundary?
+	// wb bytesEncWriter
+	wb   bytesEncAppender
+	wx   bool // if bytes, wx=true
+	esep bool // whether it has elem separators
+	isas bool // whether e.as != nil
 }
 
-// --------------------------------------------------
-
-type encRtidFn struct {
-	rtid uintptr
-	fn   encFn
-}
+// TODO: Uncomment after mid-stack inlining enabled in go 1.10
+//
+// func (z *encWriterSwitch) writeb(s []byte) {
+// 	if z.wx {
+// 		z.wb.writeb(s)
+// 	} else {
+// 		z.wi.writeb(s)
+// 	}
+// }
+// func (z *encWriterSwitch) writestr(s string) {
+// 	if z.wx {
+// 		z.wb.writestr(s)
+// 	} else {
+// 		z.wi.writestr(s)
+// 	}
+// }
+// func (z *encWriterSwitch) writen1(b1 byte) {
+// 	if z.wx {
+// 		z.wb.writen1(b1)
+// 	} else {
+// 		z.wi.writen1(b1)
+// 	}
+// }
+// func (z *encWriterSwitch) writen2(b1, b2 byte) {
+// 	if z.wx {
+// 		z.wb.writen2(b1, b2)
+// 	} else {
+// 		z.wi.writen2(b1, b2)
+// 	}
+// }
 
 // An Encoder writes an object to an output stream in the codec format.
 type Encoder struct {
+	panicHdl
 	// hopefully, reduce derefencing cost by laying the encWriter inside the Encoder
 	e encDriver
 	// NOTE: Encoder shouldn't call it's write methods,
 	// as the handler MAY need to do some coordination.
-	w  encWriter
-	s  []encRtidFn
-	ci set
-	be bool // is binary encoding
-	js bool // is json handle
+	w encWriter
 
-	wi ioEncWriter
-	wb bytesEncWriter
-
-	h  *BasicHandle
+	// ho Handle // original handle
 	hh Handle
+	h  *BasicHandle
 
-	cr containerStateRecv
+	// ---- cpu cache line boundary?
+	// cr containerStateRecv
 	as encDriverAsis
+	ci set
 
-	f map[uintptr]*encFn
-	b [scratchByteArrayLen]byte
+	// ---- cpu cache line boundary?
+	encWriterSwitch
+
+	// ---- cpu cache line boundary?
+	bw bufio.Writer
+
+	// ---- cpu cache line boundary?
+	cf codecFner
+
+	// ---- writable fields during execution --- *try* to keep in sep cache line
+
+	// ---- cpu cache line boundary?
+	b   [scratchByteArrayLen]byte
+	err error
 }
 
 // NewEncoder returns an Encoder for encoding into an io.Writer.
@@ -963,50 +1006,70 @@ func NewEncoderBytes(out *[]byte, h Handle) *Encoder {
 }
 
 func newEncoder(h Handle) *Encoder {
-	e := &Encoder{hh: h, h: h.getBasicHandle(), be: h.isBinary()}
-	_, e.js = h.(*JsonHandle)
+	e := &Encoder{hh: h, h: h.getBasicHandle(), err: errEncoderNotInitialized}
+	e.esep = h.hasElemSeparators()
 	e.e = h.newEncDriver(e)
-	e.as, _ = e.e.(encDriverAsis)
-	e.cr, _ = e.e.(containerStateRecv)
+	e.as, e.isas = e.e.(encDriverAsis)
+	// e.cr, _ = e.e.(containerStateRecv)
 	return e
 }
 
-// Reset the Encoder with a new output stream.
+func (e *Encoder) postReset() {
+	e.e.reset()
+	e.cf.reset(e.hh)
+	e.err = nil
+}
+
+// Reset resets the Encoder with a new output stream.
 //
 // This accommodates using the state of the Encoder,
 // where it has "cached" information about sub-engines.
 func (e *Encoder) Reset(w io.Writer) {
-	ww, ok := w.(ioEncWriterWriter)
-	if ok {
-		e.wi.w = ww
+	if w == nil {
+		return
+	}
+	var ok bool
+	e.wx = false
+	e.wi.w = w
+	if e.h.WriterBufferSize > 0 {
+		bw := bufio.NewWriterSize(w, e.h.WriterBufferSize)
+		e.bw = *bw
+		e.wi.bw = &e.bw
+		e.wi.sw = &e.bw
+		e.wi.fw = &e.bw
+		e.wi.ww = &e.bw
 	} else {
-		sww := &e.wi.s
-		sww.w = w
-		sww.bw, _ = w.(io.ByteWriter)
-		sww.sw, _ = w.(ioEncStringWriter)
-		e.wi.w = sww
-		//ww = bufio.NewWriterSize(w, defEncByteBufSize)
+		if e.wi.bw, ok = w.(io.ByteWriter); !ok {
+			e.wi.bw = &e.wi
+		}
+		if e.wi.sw, ok = w.(ioEncStringWriter); !ok {
+			e.wi.sw = &e.wi
+		}
+		e.wi.fw, _ = w.(ioFlusher)
+		e.wi.ww = w
 	}
 	e.w = &e.wi
-	e.e.reset()
+	e.postReset()
 }
 
+// ResetBytes resets the Encoder with a new destination output []byte.
 func (e *Encoder) ResetBytes(out *[]byte) {
-	in := *out
+	if out == nil {
+		return
+	}
+	var in []byte
+	if out != nil {
+		in = *out
+	}
 	if in == nil {
 		in = make([]byte, defEncByteBufSize)
 	}
-	e.wb.b, e.wb.out, e.wb.c = in, out, 0
+	e.wx = true
+	e.wb.reset(in, out)
 	e.w = &e.wb
-	e.e.reset()
+	e.postReset()
 }
 
-// func (e *Encoder) sendContainerState(c containerState) {
-// 	if e.cr != nil {
-// 		e.cr.sendContainerState(c)
-// 	}
-// }
-
 // Encode writes an object into a stream.
 //
 // Encoding can be configured via the struct tag for the fields.
@@ -1015,7 +1078,14 @@ func (e *Encoder) ResetBytes(out *[]byte) {
 // Note that the "json" key is used in the absence of the "codec" key.
 //
 // To set an option on all fields (e.g. omitempty on all fields), you
-// can create a field called _struct, and set flags on it.
+// can create a field called _struct, and set flags on it. The options
+// which can be set on _struct are:
+//    - omitempty: so all fields are omitted if empty
+//    - toarray: so struct is encoded as an array
+//    - int: so struct key names are encoded as signed integers (instead of strings)
+//    - uint: so struct key names are encoded as unsigned integers (instead of strings)
+//    - float: so struct key names are encoded as floats (instead of strings)
+// More details on these below.
 //
 // Struct values "usually" encode as maps. Each exported struct field is encoded unless:
 //    - the field's tag is "-", OR
@@ -1023,6 +1093,13 @@ func (e *Encoder) ResetBytes(out *[]byte) {
 //
 // When encoding as a map, the first string in the tag (before the comma)
 // is the map key string to use when encoding.
+// ...
+// This key is typically encoded as a string.
+// However, there are instances where the encoded stream has mapping keys encoded as numbers.
+// For example, some cbor streams have keys as integer codes in the stream, but they should map
+// to fields in a structured object. Consequently, a struct is the natural representation in code.
+// For these, you can configure the struct to encode/decode the keys as numbers (instead of string).
+// This is done with the int,uint or float option on the _struct field (see above).
 //
 // However, struct values may encode as arrays. This happens when:
 //    - StructToArray Encode option is set, OR
@@ -1055,7 +1132,13 @@ func (e *Encoder) ResetBytes(out *[]byte) {
 //      }
 //
 //      type MyStruct struct {
-//          _struct bool    `codec:",toarray"`   //encode struct as an array
+//          _struct bool    `codec:",toarray"`     //encode struct as an array
+//      }
+//
+//      type MyStruct struct {
+//          _struct bool    `codec:",uint"`        //encode struct with "unsigned integer" keys
+//          Field1 string   `codec:"1"`            //encode Field1 key using: EncodeInt(1)
+//          Field2 string   `codec:"2"`            //encode Field2 key using: EncodeInt(2)
 //      }
 //
 // The mode of encoding is based on the type of the value. When a value is seen:
@@ -1068,37 +1151,44 @@ func (e *Encoder) ResetBytes(out *[]byte) {
 // Some formats support symbols (e.g. binc) and will properly encode the string
 // only once in the stream, and use a tag to refer to it thereafter.
 func (e *Encoder) Encode(v interface{}) (err error) {
-	defer panicToErr(&err)
-	e.encode(v)
-	e.w.atEndOfEncode()
+	defer panicToErrs2(e, &e.err, &err)
+	e.MustEncode(v)
 	return
 }
 
 // MustEncode is like Encode, but panics if unable to Encode.
 // This provides insight to the code location that triggered the error.
 func (e *Encoder) MustEncode(v interface{}) {
+	if e.err != nil {
+		panic(e.err)
+	}
 	e.encode(v)
+	e.e.atEndOfEncode()
 	e.w.atEndOfEncode()
 }
 
 func (e *Encoder) encode(iv interface{}) {
-	// if ics, ok := iv.(Selfer); ok {
-	// 	ics.CodecEncodeSelf(e)
-	// 	return
-	// }
+	if iv == nil || definitelyNil(iv) {
+		e.e.EncodeNil()
+		return
+	}
+	if v, ok := iv.(Selfer); ok {
+		v.CodecEncodeSelf(e)
+		return
+	}
 
 	switch v := iv.(type) {
-	case nil:
-		e.e.EncodeNil()
-	case Selfer:
-		v.CodecEncodeSelf(e)
+	// case nil:
+	// 	e.e.EncodeNil()
+	// case Selfer:
+	// 	v.CodecEncodeSelf(e)
 	case Raw:
-		e.raw(v)
+		e.rawBytes(v)
 	case reflect.Value:
-		e.encodeValue(v, nil)
+		e.encodeValue(v, nil, true)
 
 	case string:
-		e.e.EncodeString(c_UTF8, v)
+		e.e.EncodeString(cUTF8, v)
 	case bool:
 		e.e.EncodeBool(v)
 	case int:
@@ -1121,16 +1211,22 @@ func (e *Encoder) encode(iv interface{}) {
 		e.e.EncodeUint(uint64(v))
 	case uint64:
 		e.e.EncodeUint(v)
+	case uintptr:
+		e.e.EncodeUint(uint64(v))
 	case float32:
 		e.e.EncodeFloat32(v)
 	case float64:
 		e.e.EncodeFloat64(v)
-
+	case time.Time:
+		e.e.EncodeTime(v)
 	case []uint8:
-		e.e.EncodeStringBytes(c_RAW, v)
+		e.e.EncodeStringBytes(cRAW, v)
+
+	case *Raw:
+		e.rawBytes(*v)
 
 	case *string:
-		e.e.EncodeString(c_UTF8, *v)
+		e.e.EncodeString(cUTF8, *v)
 	case *bool:
 		e.e.EncodeBool(*v)
 	case *int:
@@ -1153,24 +1249,31 @@ func (e *Encoder) encode(iv interface{}) {
 		e.e.EncodeUint(uint64(*v))
 	case *uint64:
 		e.e.EncodeUint(*v)
+	case *uintptr:
+		e.e.EncodeUint(uint64(*v))
 	case *float32:
 		e.e.EncodeFloat32(*v)
 	case *float64:
 		e.e.EncodeFloat64(*v)
+	case *time.Time:
+		e.e.EncodeTime(*v)
 
 	case *[]uint8:
-		e.e.EncodeStringBytes(c_RAW, *v)
+		e.e.EncodeStringBytes(cRAW, *v)
 
 	default:
-		const checkCodecSelfer1 = true // in case T is passed, where *T is a Selfer, still checkCodecSelfer
 		if !fastpathEncodeTypeSwitch(iv, e) {
-			e.encodeI(iv, false, checkCodecSelfer1)
+			// checkfastpath=true (not false), as underlying slice/map type may be fast-path
+			e.encodeValue(reflect.ValueOf(iv), nil, true)
 		}
 	}
 }
 
-func (e *Encoder) preEncodeValue(rv reflect.Value) (rv2 reflect.Value, sptr uintptr, proceed bool) {
-	// use a goto statement instead of a recursive function for ptr/interface.
+func (e *Encoder) encodeValue(rv reflect.Value, fn *codecFn, checkFastpath bool) {
+	// if a valid fn is passed, it MUST BE for the dereferenced type of rv
+	var sptr uintptr
+	var rvp reflect.Value
+	var rvpValid bool
 TOP:
 	switch rv.Kind() {
 	case reflect.Ptr:
@@ -1178,6 +1281,8 @@ TOP:
 			e.e.EncodeNil()
 			return
 		}
+		rvpValid = true
+		rvp = rv
 		rv = rv.Elem()
 		if e.h.CheckCircularRef && rv.Kind() == reflect.Struct {
 			// TODO: Movable pointers will be an issue here. Future problem.
@@ -1202,167 +1307,33 @@ TOP:
 		return
 	}
 
-	proceed = true
-	rv2 = rv
-	return
-}
-
-func (e *Encoder) doEncodeValue(rv reflect.Value, fn *encFn, sptr uintptr,
-	checkFastpath, checkCodecSelfer bool) {
-	if sptr != 0 {
-		if (&e.ci).add(sptr) {
-			e.errorf("circular reference found: # %d", sptr)
-		}
+	if sptr != 0 && (&e.ci).add(sptr) {
+		e.errorf("circular reference found: # %d", sptr)
 	}
+
 	if fn == nil {
 		rt := rv.Type()
-		rtid := rt2id(rt)
-		// fn = e.getEncFn(rtid, rt, true, true)
-		fn = e.getEncFn(rtid, rt, checkFastpath, checkCodecSelfer)
+		// always pass checkCodecSelfer=true, in case T or ****T is passed, where *T is a Selfer
+		fn = e.cf.get(rt, checkFastpath, true)
+	}
+	if fn.i.addrE {
+		if rvpValid {
+			fn.fe(e, &fn.i, rvp)
+		} else if rv.CanAddr() {
+			fn.fe(e, &fn.i, rv.Addr())
+		} else {
+			rv2 := reflect.New(rv.Type())
+			rv2.Elem().Set(rv)
+			fn.fe(e, &fn.i, rv2)
+		}
+	} else {
+		fn.fe(e, &fn.i, rv)
 	}
-	fn.f(&fn.i, rv)
 	if sptr != 0 {
 		(&e.ci).remove(sptr)
 	}
 }
 
-func (e *Encoder) encodeI(iv interface{}, checkFastpath, checkCodecSelfer bool) {
-	if rv, sptr, proceed := e.preEncodeValue(reflect.ValueOf(iv)); proceed {
-		e.doEncodeValue(rv, nil, sptr, checkFastpath, checkCodecSelfer)
-	}
-}
-
-func (e *Encoder) encodeValue(rv reflect.Value, fn *encFn) {
-	// if a valid fn is passed, it MUST BE for the dereferenced type of rv
-	if rv, sptr, proceed := e.preEncodeValue(rv); proceed {
-		e.doEncodeValue(rv, fn, sptr, true, true)
-	}
-}
-
-func (e *Encoder) getEncFn(rtid uintptr, rt reflect.Type, checkFastpath, checkCodecSelfer bool) (fn *encFn) {
-	// rtid := rt2id(rt)
-	var ok bool
-	if useMapForCodecCache {
-		fn, ok = e.f[rtid]
-	} else {
-		for i := range e.s {
-			v := &(e.s[i])
-			if v.rtid == rtid {
-				fn, ok = &(v.fn), true
-				break
-			}
-		}
-	}
-	if ok {
-		return
-	}
-
-	if useMapForCodecCache {
-		if e.f == nil {
-			e.f = make(map[uintptr]*encFn, initCollectionCap)
-		}
-		fn = new(encFn)
-		e.f[rtid] = fn
-	} else {
-		if e.s == nil {
-			e.s = make([]encRtidFn, 0, initCollectionCap)
-		}
-		e.s = append(e.s, encRtidFn{rtid: rtid})
-		fn = &(e.s[len(e.s)-1]).fn
-	}
-
-	ti := e.h.getTypeInfo(rtid, rt)
-	fi := &(fn.i)
-	fi.e = e
-	fi.ti = ti
-
-	if checkCodecSelfer && ti.cs {
-		fn.f = (*encFnInfo).selferMarshal
-	} else if rtid == rawTypId {
-		fn.f = (*encFnInfo).raw
-	} else if rtid == rawExtTypId {
-		fn.f = (*encFnInfo).rawExt
-	} else if e.e.IsBuiltinType(rtid) {
-		fn.f = (*encFnInfo).builtin
-	} else if xfFn := e.h.getExt(rtid); xfFn != nil {
-		fi.xfTag, fi.xfFn = xfFn.tag, xfFn.ext
-		fn.f = (*encFnInfo).ext
-	} else if supportMarshalInterfaces && e.be && ti.bm {
-		fn.f = (*encFnInfo).binaryMarshal
-	} else if supportMarshalInterfaces && !e.be && e.js && ti.jm {
-		//If JSON, we should check JSONMarshal before textMarshal
-		fn.f = (*encFnInfo).jsonMarshal
-	} else if supportMarshalInterfaces && !e.be && ti.tm {
-		fn.f = (*encFnInfo).textMarshal
-	} else {
-		rk := rt.Kind()
-		if fastpathEnabled && checkFastpath && (rk == reflect.Map || rk == reflect.Slice) {
-			if rt.PkgPath() == "" { // un-named slice or map
-				if idx := fastpathAV.index(rtid); idx != -1 {
-					fn.f = fastpathAV[idx].encfn
-				}
-			} else {
-				ok = false
-				// use mapping for underlying type if there
-				var rtu reflect.Type
-				if rk == reflect.Map {
-					rtu = reflect.MapOf(rt.Key(), rt.Elem())
-				} else {
-					rtu = reflect.SliceOf(rt.Elem())
-				}
-				rtuid := rt2id(rtu)
-				if idx := fastpathAV.index(rtuid); idx != -1 {
-					xfnf := fastpathAV[idx].encfn
-					xrt := fastpathAV[idx].rt
-					fn.f = func(xf *encFnInfo, xrv reflect.Value) {
-						xfnf(xf, xrv.Convert(xrt))
-					}
-				}
-			}
-		}
-		if fn.f == nil {
-			switch rk {
-			case reflect.Bool:
-				fn.f = (*encFnInfo).kBool
-			case reflect.String:
-				fn.f = (*encFnInfo).kString
-			case reflect.Float64:
-				fn.f = (*encFnInfo).kFloat64
-			case reflect.Float32:
-				fn.f = (*encFnInfo).kFloat32
-			case reflect.Int, reflect.Int8, reflect.Int64, reflect.Int32, reflect.Int16:
-				fn.f = (*encFnInfo).kInt
-			case reflect.Uint8, reflect.Uint64, reflect.Uint, reflect.Uint32, reflect.Uint16, reflect.Uintptr:
-				fn.f = (*encFnInfo).kUint
-			case reflect.Invalid:
-				fn.f = (*encFnInfo).kInvalid
-			case reflect.Chan:
-				fi.seq = seqTypeChan
-				fn.f = (*encFnInfo).kSlice
-			case reflect.Slice:
-				fi.seq = seqTypeSlice
-				fn.f = (*encFnInfo).kSlice
-			case reflect.Array:
-				fi.seq = seqTypeArray
-				fn.f = (*encFnInfo).kSlice
-			case reflect.Struct:
-				fn.f = (*encFnInfo).kStruct
-				// reflect.Ptr and reflect.Interface are handled already by preEncodeValue
-				// case reflect.Ptr:
-				// 	fn.f = (*encFnInfo).kPtr
-				// case reflect.Interface:
-				// 	fn.f = (*encFnInfo).kInterface
-			case reflect.Map:
-				fn.f = (*encFnInfo).kMap
-			default:
-				fn.f = (*encFnInfo).kErr
-			}
-		}
-	}
-
-	return
-}
-
 func (e *Encoder) marshal(bs []byte, fnerr error, asis bool, c charEncoding) {
 	if fnerr != nil {
 		panic(fnerr)
@@ -1377,86 +1348,21 @@ func (e *Encoder) marshal(bs []byte, fnerr error, asis bool, c charEncoding) {
 }
 
 func (e *Encoder) asis(v []byte) {
-	if e.as == nil {
-		e.w.writeb(v)
-	} else {
+	if e.isas {
 		e.as.EncodeAsis(v)
+	} else {
+		e.w.writeb(v)
 	}
 }
 
-func (e *Encoder) raw(vv Raw) {
+func (e *Encoder) rawBytes(vv Raw) {
 	v := []byte(vv)
 	if !e.h.Raw {
 		e.errorf("Raw values cannot be encoded: %v", v)
 	}
-	if e.as == nil {
-		e.w.writeb(v)
-	} else {
-		e.as.EncodeAsis(v)
-	}
+	e.asis(v)
 }
 
-func (e *Encoder) errorf(format string, params ...interface{}) {
-	err := fmt.Errorf(format, params...)
-	panic(err)
+func (e *Encoder) wrapErrstr(v interface{}, err *error) {
+	*err = fmt.Errorf("%s encode error: %v", e.hh.Name(), v)
 }
-
-// ----------------------------------------
-
-const encStructPoolLen = 5
-
-// encStructPool is an array of sync.Pool.
-// Each element of the array pools one of encStructPool(8|16|32|64).
-// It allows the re-use of slices up to 64 in length.
-// A performance cost of encoding structs was collecting
-// which values were empty and should be omitted.
-// We needed slices of reflect.Value and string to collect them.
-// This shared pool reduces the amount of unnecessary creation we do.
-// The cost is that of locking sometimes, but sync.Pool is efficient
-// enough to reduce thread contention.
-var encStructPool [encStructPoolLen]sync.Pool
-
-func init() {
-	encStructPool[0].New = func() interface{} { return new([8]stringRv) }
-	encStructPool[1].New = func() interface{} { return new([16]stringRv) }
-	encStructPool[2].New = func() interface{} { return new([32]stringRv) }
-	encStructPool[3].New = func() interface{} { return new([64]stringRv) }
-	encStructPool[4].New = func() interface{} { return new([128]stringRv) }
-}
-
-func encStructPoolGet(newlen int) (p *sync.Pool, v interface{}, s []stringRv) {
-	// if encStructPoolLen != 5 { // constant chec, so removed at build time.
-	// 	panic(errors.New("encStructPoolLen must be equal to 4")) // defensive, in case it is changed
-	// }
-	// idxpool := newlen / 8
-	if newlen <= 8 {
-		p = &encStructPool[0]
-		v = p.Get()
-		s = v.(*[8]stringRv)[:newlen]
-	} else if newlen <= 16 {
-		p = &encStructPool[1]
-		v = p.Get()
-		s = v.(*[16]stringRv)[:newlen]
-	} else if newlen <= 32 {
-		p = &encStructPool[2]
-		v = p.Get()
-		s = v.(*[32]stringRv)[:newlen]
-	} else if newlen <= 64 {
-		p = &encStructPool[3]
-		v = p.Get()
-		s = v.(*[64]stringRv)[:newlen]
-	} else if newlen <= 128 {
-		p = &encStructPool[4]
-		v = p.Get()
-		s = v.(*[128]stringRv)[:newlen]
-	} else {
-		s = make([]stringRv, newlen)
-	}
-	return
-}
-
-// ----------------------------------------
-
-// func encErr(format string, params ...interface{}) {
-// 	doPanic(msgTagEnc, format, params...)
-// }
diff --git a/vendor/github.com/ugorji/go/codec/fast-path.generated.go b/vendor/github.com/ugorji/go/codec/fast-path.generated.go
index a1abd55c4..1250a2e7e 100644
--- a/vendor/github.com/ugorji/go/codec/fast-path.generated.go
+++ b/vendor/github.com/ugorji/go/codec/fast-path.generated.go
@@ -3,10 +3,7 @@
 // Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
 // Use of this source code is governed by a MIT license found in the LICENSE file.
 
-// ************************************************************
-// DO NOT EDIT.
-// THIS FILE IS AUTO-GENERATED from fast-path.go.tmpl
-// ************************************************************
+// Code generated from fast-path.go.tmpl - DO NOT EDIT.
 
 package codec
 
@@ -18,19 +15,19 @@ package codec
 // This file can be omitted without causing a build failure.
 //
 // The advantage of fast paths is:
-//    - Many calls bypass reflection altogether
+//	  - Many calls bypass reflection altogether
 //
 // Currently support
-//    - slice of all builtin types,
-//    - map of all builtin types to string or interface value
-//    - symmetrical maps of all builtin types (e.g. str-str, uint8-uint8)
+//	  - slice of all builtin types,
+//	  - map of all builtin types to string or interface value
+//	  - symmetrical maps of all builtin types (e.g. str-str, uint8-uint8)
 // This should provide adequate "typical" implementations.
 //
 // Note that fast track decode functions must handle values for which an address cannot be obtained.
 // For example:
-//   m2 := map[string]int{}
-//   p2 := []interface{}{m2}
-//   // decoding into p2 will bomb if fast track functions do not treat like unaddressable.
+//	 m2 := map[string]int{}
+//	 p2 := []interface{}{m2}
+//	 // decoding into p2 will bomb if fast track functions do not treat like unaddressable.
 //
 
 import (
@@ -40,9 +37,6 @@ import (
 
 const fastpathEnabled = true
 
-const fastpathCheckNilFalse = false // for reflect
-const fastpathCheckNilTrue = true   // for type switch
-
 type fastpathT struct{}
 
 var fastpathTV fastpathT
@@ -50,8 +44,8 @@ var fastpathTV fastpathT
 type fastpathE struct {
 	rtid  uintptr
 	rt    reflect.Type
-	encfn func(*encFnInfo, reflect.Value)
-	decfn func(*decFnInfo, reflect.Value)
+	encfn func(*Encoder, *codecFnInfo, reflect.Value)
+	decfn func(*Decoder, *codecFnInfo, reflect.Value)
 }
 
 type fastpathA [271]fastpathE
@@ -84,7 +78,9 @@ var fastpathAV fastpathA
 // due to possible initialization loop error, make fastpath in an init()
 func init() {
 	i := 0
-	fn := func(v interface{}, fe func(*encFnInfo, reflect.Value), fd func(*decFnInfo, reflect.Value)) (f fastpathE) {
+	fn := func(v interface{},
+		fe func(*Encoder, *codecFnInfo, reflect.Value),
+		fd func(*Decoder, *codecFnInfo, reflect.Value)) (f fastpathE) {
 		xrt := reflect.TypeOf(v)
 		xptr := rt2id(xrt)
 		fastpathAV[i] = fastpathE{xptr, xrt, fe, fd}
@@ -92,278 +88,278 @@ func init() {
 		return
 	}
 
-	fn([]interface{}(nil), (*encFnInfo).fastpathEncSliceIntfR, (*decFnInfo).fastpathDecSliceIntfR)
-	fn([]string(nil), (*encFnInfo).fastpathEncSliceStringR, (*decFnInfo).fastpathDecSliceStringR)
-	fn([]float32(nil), (*encFnInfo).fastpathEncSliceFloat32R, (*decFnInfo).fastpathDecSliceFloat32R)
-	fn([]float64(nil), (*encFnInfo).fastpathEncSliceFloat64R, (*decFnInfo).fastpathDecSliceFloat64R)
-	fn([]uint(nil), (*encFnInfo).fastpathEncSliceUintR, (*decFnInfo).fastpathDecSliceUintR)
-	fn([]uint16(nil), (*encFnInfo).fastpathEncSliceUint16R, (*decFnInfo).fastpathDecSliceUint16R)
-	fn([]uint32(nil), (*encFnInfo).fastpathEncSliceUint32R, (*decFnInfo).fastpathDecSliceUint32R)
-	fn([]uint64(nil), (*encFnInfo).fastpathEncSliceUint64R, (*decFnInfo).fastpathDecSliceUint64R)
-	fn([]uintptr(nil), (*encFnInfo).fastpathEncSliceUintptrR, (*decFnInfo).fastpathDecSliceUintptrR)
-	fn([]int(nil), (*encFnInfo).fastpathEncSliceIntR, (*decFnInfo).fastpathDecSliceIntR)
-	fn([]int8(nil), (*encFnInfo).fastpathEncSliceInt8R, (*decFnInfo).fastpathDecSliceInt8R)
-	fn([]int16(nil), (*encFnInfo).fastpathEncSliceInt16R, (*decFnInfo).fastpathDecSliceInt16R)
-	fn([]int32(nil), (*encFnInfo).fastpathEncSliceInt32R, (*decFnInfo).fastpathDecSliceInt32R)
-	fn([]int64(nil), (*encFnInfo).fastpathEncSliceInt64R, (*decFnInfo).fastpathDecSliceInt64R)
-	fn([]bool(nil), (*encFnInfo).fastpathEncSliceBoolR, (*decFnInfo).fastpathDecSliceBoolR)
+	fn([]interface{}(nil), (*Encoder).fastpathEncSliceIntfR, (*Decoder).fastpathDecSliceIntfR)
+	fn([]string(nil), (*Encoder).fastpathEncSliceStringR, (*Decoder).fastpathDecSliceStringR)
+	fn([]float32(nil), (*Encoder).fastpathEncSliceFloat32R, (*Decoder).fastpathDecSliceFloat32R)
+	fn([]float64(nil), (*Encoder).fastpathEncSliceFloat64R, (*Decoder).fastpathDecSliceFloat64R)
+	fn([]uint(nil), (*Encoder).fastpathEncSliceUintR, (*Decoder).fastpathDecSliceUintR)
+	fn([]uint16(nil), (*Encoder).fastpathEncSliceUint16R, (*Decoder).fastpathDecSliceUint16R)
+	fn([]uint32(nil), (*Encoder).fastpathEncSliceUint32R, (*Decoder).fastpathDecSliceUint32R)
+	fn([]uint64(nil), (*Encoder).fastpathEncSliceUint64R, (*Decoder).fastpathDecSliceUint64R)
+	fn([]uintptr(nil), (*Encoder).fastpathEncSliceUintptrR, (*Decoder).fastpathDecSliceUintptrR)
+	fn([]int(nil), (*Encoder).fastpathEncSliceIntR, (*Decoder).fastpathDecSliceIntR)
+	fn([]int8(nil), (*Encoder).fastpathEncSliceInt8R, (*Decoder).fastpathDecSliceInt8R)
+	fn([]int16(nil), (*Encoder).fastpathEncSliceInt16R, (*Decoder).fastpathDecSliceInt16R)
+	fn([]int32(nil), (*Encoder).fastpathEncSliceInt32R, (*Decoder).fastpathDecSliceInt32R)
+	fn([]int64(nil), (*Encoder).fastpathEncSliceInt64R, (*Decoder).fastpathDecSliceInt64R)
+	fn([]bool(nil), (*Encoder).fastpathEncSliceBoolR, (*Decoder).fastpathDecSliceBoolR)
 
-	fn(map[interface{}]interface{}(nil), (*encFnInfo).fastpathEncMapIntfIntfR, (*decFnInfo).fastpathDecMapIntfIntfR)
-	fn(map[interface{}]string(nil), (*encFnInfo).fastpathEncMapIntfStringR, (*decFnInfo).fastpathDecMapIntfStringR)
-	fn(map[interface{}]uint(nil), (*encFnInfo).fastpathEncMapIntfUintR, (*decFnInfo).fastpathDecMapIntfUintR)
-	fn(map[interface{}]uint8(nil), (*encFnInfo).fastpathEncMapIntfUint8R, (*decFnInfo).fastpathDecMapIntfUint8R)
-	fn(map[interface{}]uint16(nil), (*encFnInfo).fastpathEncMapIntfUint16R, (*decFnInfo).fastpathDecMapIntfUint16R)
-	fn(map[interface{}]uint32(nil), (*encFnInfo).fastpathEncMapIntfUint32R, (*decFnInfo).fastpathDecMapIntfUint32R)
-	fn(map[interface{}]uint64(nil), (*encFnInfo).fastpathEncMapIntfUint64R, (*decFnInfo).fastpathDecMapIntfUint64R)
-	fn(map[interface{}]uintptr(nil), (*encFnInfo).fastpathEncMapIntfUintptrR, (*decFnInfo).fastpathDecMapIntfUintptrR)
-	fn(map[interface{}]int(nil), (*encFnInfo).fastpathEncMapIntfIntR, (*decFnInfo).fastpathDecMapIntfIntR)
-	fn(map[interface{}]int8(nil), (*encFnInfo).fastpathEncMapIntfInt8R, (*decFnInfo).fastpathDecMapIntfInt8R)
-	fn(map[interface{}]int16(nil), (*encFnInfo).fastpathEncMapIntfInt16R, (*decFnInfo).fastpathDecMapIntfInt16R)
-	fn(map[interface{}]int32(nil), (*encFnInfo).fastpathEncMapIntfInt32R, (*decFnInfo).fastpathDecMapIntfInt32R)
-	fn(map[interface{}]int64(nil), (*encFnInfo).fastpathEncMapIntfInt64R, (*decFnInfo).fastpathDecMapIntfInt64R)
-	fn(map[interface{}]float32(nil), (*encFnInfo).fastpathEncMapIntfFloat32R, (*decFnInfo).fastpathDecMapIntfFloat32R)
-	fn(map[interface{}]float64(nil), (*encFnInfo).fastpathEncMapIntfFloat64R, (*decFnInfo).fastpathDecMapIntfFloat64R)
-	fn(map[interface{}]bool(nil), (*encFnInfo).fastpathEncMapIntfBoolR, (*decFnInfo).fastpathDecMapIntfBoolR)
-	fn(map[string]interface{}(nil), (*encFnInfo).fastpathEncMapStringIntfR, (*decFnInfo).fastpathDecMapStringIntfR)
-	fn(map[string]string(nil), (*encFnInfo).fastpathEncMapStringStringR, (*decFnInfo).fastpathDecMapStringStringR)
-	fn(map[string]uint(nil), (*encFnInfo).fastpathEncMapStringUintR, (*decFnInfo).fastpathDecMapStringUintR)
-	fn(map[string]uint8(nil), (*encFnInfo).fastpathEncMapStringUint8R, (*decFnInfo).fastpathDecMapStringUint8R)
-	fn(map[string]uint16(nil), (*encFnInfo).fastpathEncMapStringUint16R, (*decFnInfo).fastpathDecMapStringUint16R)
-	fn(map[string]uint32(nil), (*encFnInfo).fastpathEncMapStringUint32R, (*decFnInfo).fastpathDecMapStringUint32R)
-	fn(map[string]uint64(nil), (*encFnInfo).fastpathEncMapStringUint64R, (*decFnInfo).fastpathDecMapStringUint64R)
-	fn(map[string]uintptr(nil), (*encFnInfo).fastpathEncMapStringUintptrR, (*decFnInfo).fastpathDecMapStringUintptrR)
-	fn(map[string]int(nil), (*encFnInfo).fastpathEncMapStringIntR, (*decFnInfo).fastpathDecMapStringIntR)
-	fn(map[string]int8(nil), (*encFnInfo).fastpathEncMapStringInt8R, (*decFnInfo).fastpathDecMapStringInt8R)
-	fn(map[string]int16(nil), (*encFnInfo).fastpathEncMapStringInt16R, (*decFnInfo).fastpathDecMapStringInt16R)
-	fn(map[string]int32(nil), (*encFnInfo).fastpathEncMapStringInt32R, (*decFnInfo).fastpathDecMapStringInt32R)
-	fn(map[string]int64(nil), (*encFnInfo).fastpathEncMapStringInt64R, (*decFnInfo).fastpathDecMapStringInt64R)
-	fn(map[string]float32(nil), (*encFnInfo).fastpathEncMapStringFloat32R, (*decFnInfo).fastpathDecMapStringFloat32R)
-	fn(map[string]float64(nil), (*encFnInfo).fastpathEncMapStringFloat64R, (*decFnInfo).fastpathDecMapStringFloat64R)
-	fn(map[string]bool(nil), (*encFnInfo).fastpathEncMapStringBoolR, (*decFnInfo).fastpathDecMapStringBoolR)
-	fn(map[float32]interface{}(nil), (*encFnInfo).fastpathEncMapFloat32IntfR, (*decFnInfo).fastpathDecMapFloat32IntfR)
-	fn(map[float32]string(nil), (*encFnInfo).fastpathEncMapFloat32StringR, (*decFnInfo).fastpathDecMapFloat32StringR)
-	fn(map[float32]uint(nil), (*encFnInfo).fastpathEncMapFloat32UintR, (*decFnInfo).fastpathDecMapFloat32UintR)
-	fn(map[float32]uint8(nil), (*encFnInfo).fastpathEncMapFloat32Uint8R, (*decFnInfo).fastpathDecMapFloat32Uint8R)
-	fn(map[float32]uint16(nil), (*encFnInfo).fastpathEncMapFloat32Uint16R, (*decFnInfo).fastpathDecMapFloat32Uint16R)
-	fn(map[float32]uint32(nil), (*encFnInfo).fastpathEncMapFloat32Uint32R, (*decFnInfo).fastpathDecMapFloat32Uint32R)
-	fn(map[float32]uint64(nil), (*encFnInfo).fastpathEncMapFloat32Uint64R, (*decFnInfo).fastpathDecMapFloat32Uint64R)
-	fn(map[float32]uintptr(nil), (*encFnInfo).fastpathEncMapFloat32UintptrR, (*decFnInfo).fastpathDecMapFloat32UintptrR)
-	fn(map[float32]int(nil), (*encFnInfo).fastpathEncMapFloat32IntR, (*decFnInfo).fastpathDecMapFloat32IntR)
-	fn(map[float32]int8(nil), (*encFnInfo).fastpathEncMapFloat32Int8R, (*decFnInfo).fastpathDecMapFloat32Int8R)
-	fn(map[float32]int16(nil), (*encFnInfo).fastpathEncMapFloat32Int16R, (*decFnInfo).fastpathDecMapFloat32Int16R)
-	fn(map[float32]int32(nil), (*encFnInfo).fastpathEncMapFloat32Int32R, (*decFnInfo).fastpathDecMapFloat32Int32R)
-	fn(map[float32]int64(nil), (*encFnInfo).fastpathEncMapFloat32Int64R, (*decFnInfo).fastpathDecMapFloat32Int64R)
-	fn(map[float32]float32(nil), (*encFnInfo).fastpathEncMapFloat32Float32R, (*decFnInfo).fastpathDecMapFloat32Float32R)
-	fn(map[float32]float64(nil), (*encFnInfo).fastpathEncMapFloat32Float64R, (*decFnInfo).fastpathDecMapFloat32Float64R)
-	fn(map[float32]bool(nil), (*encFnInfo).fastpathEncMapFloat32BoolR, (*decFnInfo).fastpathDecMapFloat32BoolR)
-	fn(map[float64]interface{}(nil), (*encFnInfo).fastpathEncMapFloat64IntfR, (*decFnInfo).fastpathDecMapFloat64IntfR)
-	fn(map[float64]string(nil), (*encFnInfo).fastpathEncMapFloat64StringR, (*decFnInfo).fastpathDecMapFloat64StringR)
-	fn(map[float64]uint(nil), (*encFnInfo).fastpathEncMapFloat64UintR, (*decFnInfo).fastpathDecMapFloat64UintR)
-	fn(map[float64]uint8(nil), (*encFnInfo).fastpathEncMapFloat64Uint8R, (*decFnInfo).fastpathDecMapFloat64Uint8R)
-	fn(map[float64]uint16(nil), (*encFnInfo).fastpathEncMapFloat64Uint16R, (*decFnInfo).fastpathDecMapFloat64Uint16R)
-	fn(map[float64]uint32(nil), (*encFnInfo).fastpathEncMapFloat64Uint32R, (*decFnInfo).fastpathDecMapFloat64Uint32R)
-	fn(map[float64]uint64(nil), (*encFnInfo).fastpathEncMapFloat64Uint64R, (*decFnInfo).fastpathDecMapFloat64Uint64R)
-	fn(map[float64]uintptr(nil), (*encFnInfo).fastpathEncMapFloat64UintptrR, (*decFnInfo).fastpathDecMapFloat64UintptrR)
-	fn(map[float64]int(nil), (*encFnInfo).fastpathEncMapFloat64IntR, (*decFnInfo).fastpathDecMapFloat64IntR)
-	fn(map[float64]int8(nil), (*encFnInfo).fastpathEncMapFloat64Int8R, (*decFnInfo).fastpathDecMapFloat64Int8R)
-	fn(map[float64]int16(nil), (*encFnInfo).fastpathEncMapFloat64Int16R, (*decFnInfo).fastpathDecMapFloat64Int16R)
-	fn(map[float64]int32(nil), (*encFnInfo).fastpathEncMapFloat64Int32R, (*decFnInfo).fastpathDecMapFloat64Int32R)
-	fn(map[float64]int64(nil), (*encFnInfo).fastpathEncMapFloat64Int64R, (*decFnInfo).fastpathDecMapFloat64Int64R)
-	fn(map[float64]float32(nil), (*encFnInfo).fastpathEncMapFloat64Float32R, (*decFnInfo).fastpathDecMapFloat64Float32R)
-	fn(map[float64]float64(nil), (*encFnInfo).fastpathEncMapFloat64Float64R, (*decFnInfo).fastpathDecMapFloat64Float64R)
-	fn(map[float64]bool(nil), (*encFnInfo).fastpathEncMapFloat64BoolR, (*decFnInfo).fastpathDecMapFloat64BoolR)
-	fn(map[uint]interface{}(nil), (*encFnInfo).fastpathEncMapUintIntfR, (*decFnInfo).fastpathDecMapUintIntfR)
-	fn(map[uint]string(nil), (*encFnInfo).fastpathEncMapUintStringR, (*decFnInfo).fastpathDecMapUintStringR)
-	fn(map[uint]uint(nil), (*encFnInfo).fastpathEncMapUintUintR, (*decFnInfo).fastpathDecMapUintUintR)
-	fn(map[uint]uint8(nil), (*encFnInfo).fastpathEncMapUintUint8R, (*decFnInfo).fastpathDecMapUintUint8R)
-	fn(map[uint]uint16(nil), (*encFnInfo).fastpathEncMapUintUint16R, (*decFnInfo).fastpathDecMapUintUint16R)
-	fn(map[uint]uint32(nil), (*encFnInfo).fastpathEncMapUintUint32R, (*decFnInfo).fastpathDecMapUintUint32R)
-	fn(map[uint]uint64(nil), (*encFnInfo).fastpathEncMapUintUint64R, (*decFnInfo).fastpathDecMapUintUint64R)
-	fn(map[uint]uintptr(nil), (*encFnInfo).fastpathEncMapUintUintptrR, (*decFnInfo).fastpathDecMapUintUintptrR)
-	fn(map[uint]int(nil), (*encFnInfo).fastpathEncMapUintIntR, (*decFnInfo).fastpathDecMapUintIntR)
-	fn(map[uint]int8(nil), (*encFnInfo).fastpathEncMapUintInt8R, (*decFnInfo).fastpathDecMapUintInt8R)
-	fn(map[uint]int16(nil), (*encFnInfo).fastpathEncMapUintInt16R, (*decFnInfo).fastpathDecMapUintInt16R)
-	fn(map[uint]int32(nil), (*encFnInfo).fastpathEncMapUintInt32R, (*decFnInfo).fastpathDecMapUintInt32R)
-	fn(map[uint]int64(nil), (*encFnInfo).fastpathEncMapUintInt64R, (*decFnInfo).fastpathDecMapUintInt64R)
-	fn(map[uint]float32(nil), (*encFnInfo).fastpathEncMapUintFloat32R, (*decFnInfo).fastpathDecMapUintFloat32R)
-	fn(map[uint]float64(nil), (*encFnInfo).fastpathEncMapUintFloat64R, (*decFnInfo).fastpathDecMapUintFloat64R)
-	fn(map[uint]bool(nil), (*encFnInfo).fastpathEncMapUintBoolR, (*decFnInfo).fastpathDecMapUintBoolR)
-	fn(map[uint8]interface{}(nil), (*encFnInfo).fastpathEncMapUint8IntfR, (*decFnInfo).fastpathDecMapUint8IntfR)
-	fn(map[uint8]string(nil), (*encFnInfo).fastpathEncMapUint8StringR, (*decFnInfo).fastpathDecMapUint8StringR)
-	fn(map[uint8]uint(nil), (*encFnInfo).fastpathEncMapUint8UintR, (*decFnInfo).fastpathDecMapUint8UintR)
-	fn(map[uint8]uint8(nil), (*encFnInfo).fastpathEncMapUint8Uint8R, (*decFnInfo).fastpathDecMapUint8Uint8R)
-	fn(map[uint8]uint16(nil), (*encFnInfo).fastpathEncMapUint8Uint16R, (*decFnInfo).fastpathDecMapUint8Uint16R)
-	fn(map[uint8]uint32(nil), (*encFnInfo).fastpathEncMapUint8Uint32R, (*decFnInfo).fastpathDecMapUint8Uint32R)
-	fn(map[uint8]uint64(nil), (*encFnInfo).fastpathEncMapUint8Uint64R, (*decFnInfo).fastpathDecMapUint8Uint64R)
-	fn(map[uint8]uintptr(nil), (*encFnInfo).fastpathEncMapUint8UintptrR, (*decFnInfo).fastpathDecMapUint8UintptrR)
-	fn(map[uint8]int(nil), (*encFnInfo).fastpathEncMapUint8IntR, (*decFnInfo).fastpathDecMapUint8IntR)
-	fn(map[uint8]int8(nil), (*encFnInfo).fastpathEncMapUint8Int8R, (*decFnInfo).fastpathDecMapUint8Int8R)
-	fn(map[uint8]int16(nil), (*encFnInfo).fastpathEncMapUint8Int16R, (*decFnInfo).fastpathDecMapUint8Int16R)
-	fn(map[uint8]int32(nil), (*encFnInfo).fastpathEncMapUint8Int32R, (*decFnInfo).fastpathDecMapUint8Int32R)
-	fn(map[uint8]int64(nil), (*encFnInfo).fastpathEncMapUint8Int64R, (*decFnInfo).fastpathDecMapUint8Int64R)
-	fn(map[uint8]float32(nil), (*encFnInfo).fastpathEncMapUint8Float32R, (*decFnInfo).fastpathDecMapUint8Float32R)
-	fn(map[uint8]float64(nil), (*encFnInfo).fastpathEncMapUint8Float64R, (*decFnInfo).fastpathDecMapUint8Float64R)
-	fn(map[uint8]bool(nil), (*encFnInfo).fastpathEncMapUint8BoolR, (*decFnInfo).fastpathDecMapUint8BoolR)
-	fn(map[uint16]interface{}(nil), (*encFnInfo).fastpathEncMapUint16IntfR, (*decFnInfo).fastpathDecMapUint16IntfR)
-	fn(map[uint16]string(nil), (*encFnInfo).fastpathEncMapUint16StringR, (*decFnInfo).fastpathDecMapUint16StringR)
-	fn(map[uint16]uint(nil), (*encFnInfo).fastpathEncMapUint16UintR, (*decFnInfo).fastpathDecMapUint16UintR)
-	fn(map[uint16]uint8(nil), (*encFnInfo).fastpathEncMapUint16Uint8R, (*decFnInfo).fastpathDecMapUint16Uint8R)
-	fn(map[uint16]uint16(nil), (*encFnInfo).fastpathEncMapUint16Uint16R, (*decFnInfo).fastpathDecMapUint16Uint16R)
-	fn(map[uint16]uint32(nil), (*encFnInfo).fastpathEncMapUint16Uint32R, (*decFnInfo).fastpathDecMapUint16Uint32R)
-	fn(map[uint16]uint64(nil), (*encFnInfo).fastpathEncMapUint16Uint64R, (*decFnInfo).fastpathDecMapUint16Uint64R)
-	fn(map[uint16]uintptr(nil), (*encFnInfo).fastpathEncMapUint16UintptrR, (*decFnInfo).fastpathDecMapUint16UintptrR)
-	fn(map[uint16]int(nil), (*encFnInfo).fastpathEncMapUint16IntR, (*decFnInfo).fastpathDecMapUint16IntR)
-	fn(map[uint16]int8(nil), (*encFnInfo).fastpathEncMapUint16Int8R, (*decFnInfo).fastpathDecMapUint16Int8R)
-	fn(map[uint16]int16(nil), (*encFnInfo).fastpathEncMapUint16Int16R, (*decFnInfo).fastpathDecMapUint16Int16R)
-	fn(map[uint16]int32(nil), (*encFnInfo).fastpathEncMapUint16Int32R, (*decFnInfo).fastpathDecMapUint16Int32R)
-	fn(map[uint16]int64(nil), (*encFnInfo).fastpathEncMapUint16Int64R, (*decFnInfo).fastpathDecMapUint16Int64R)
-	fn(map[uint16]float32(nil), (*encFnInfo).fastpathEncMapUint16Float32R, (*decFnInfo).fastpathDecMapUint16Float32R)
-	fn(map[uint16]float64(nil), (*encFnInfo).fastpathEncMapUint16Float64R, (*decFnInfo).fastpathDecMapUint16Float64R)
-	fn(map[uint16]bool(nil), (*encFnInfo).fastpathEncMapUint16BoolR, (*decFnInfo).fastpathDecMapUint16BoolR)
-	fn(map[uint32]interface{}(nil), (*encFnInfo).fastpathEncMapUint32IntfR, (*decFnInfo).fastpathDecMapUint32IntfR)
-	fn(map[uint32]string(nil), (*encFnInfo).fastpathEncMapUint32StringR, (*decFnInfo).fastpathDecMapUint32StringR)
-	fn(map[uint32]uint(nil), (*encFnInfo).fastpathEncMapUint32UintR, (*decFnInfo).fastpathDecMapUint32UintR)
-	fn(map[uint32]uint8(nil), (*encFnInfo).fastpathEncMapUint32Uint8R, (*decFnInfo).fastpathDecMapUint32Uint8R)
-	fn(map[uint32]uint16(nil), (*encFnInfo).fastpathEncMapUint32Uint16R, (*decFnInfo).fastpathDecMapUint32Uint16R)
-	fn(map[uint32]uint32(nil), (*encFnInfo).fastpathEncMapUint32Uint32R, (*decFnInfo).fastpathDecMapUint32Uint32R)
-	fn(map[uint32]uint64(nil), (*encFnInfo).fastpathEncMapUint32Uint64R, (*decFnInfo).fastpathDecMapUint32Uint64R)
-	fn(map[uint32]uintptr(nil), (*encFnInfo).fastpathEncMapUint32UintptrR, (*decFnInfo).fastpathDecMapUint32UintptrR)
-	fn(map[uint32]int(nil), (*encFnInfo).fastpathEncMapUint32IntR, (*decFnInfo).fastpathDecMapUint32IntR)
-	fn(map[uint32]int8(nil), (*encFnInfo).fastpathEncMapUint32Int8R, (*decFnInfo).fastpathDecMapUint32Int8R)
-	fn(map[uint32]int16(nil), (*encFnInfo).fastpathEncMapUint32Int16R, (*decFnInfo).fastpathDecMapUint32Int16R)
-	fn(map[uint32]int32(nil), (*encFnInfo).fastpathEncMapUint32Int32R, (*decFnInfo).fastpathDecMapUint32Int32R)
-	fn(map[uint32]int64(nil), (*encFnInfo).fastpathEncMapUint32Int64R, (*decFnInfo).fastpathDecMapUint32Int64R)
-	fn(map[uint32]float32(nil), (*encFnInfo).fastpathEncMapUint32Float32R, (*decFnInfo).fastpathDecMapUint32Float32R)
-	fn(map[uint32]float64(nil), (*encFnInfo).fastpathEncMapUint32Float64R, (*decFnInfo).fastpathDecMapUint32Float64R)
-	fn(map[uint32]bool(nil), (*encFnInfo).fastpathEncMapUint32BoolR, (*decFnInfo).fastpathDecMapUint32BoolR)
-	fn(map[uint64]interface{}(nil), (*encFnInfo).fastpathEncMapUint64IntfR, (*decFnInfo).fastpathDecMapUint64IntfR)
-	fn(map[uint64]string(nil), (*encFnInfo).fastpathEncMapUint64StringR, (*decFnInfo).fastpathDecMapUint64StringR)
-	fn(map[uint64]uint(nil), (*encFnInfo).fastpathEncMapUint64UintR, (*decFnInfo).fastpathDecMapUint64UintR)
-	fn(map[uint64]uint8(nil), (*encFnInfo).fastpathEncMapUint64Uint8R, (*decFnInfo).fastpathDecMapUint64Uint8R)
-	fn(map[uint64]uint16(nil), (*encFnInfo).fastpathEncMapUint64Uint16R, (*decFnInfo).fastpathDecMapUint64Uint16R)
-	fn(map[uint64]uint32(nil), (*encFnInfo).fastpathEncMapUint64Uint32R, (*decFnInfo).fastpathDecMapUint64Uint32R)
-	fn(map[uint64]uint64(nil), (*encFnInfo).fastpathEncMapUint64Uint64R, (*decFnInfo).fastpathDecMapUint64Uint64R)
-	fn(map[uint64]uintptr(nil), (*encFnInfo).fastpathEncMapUint64UintptrR, (*decFnInfo).fastpathDecMapUint64UintptrR)
-	fn(map[uint64]int(nil), (*encFnInfo).fastpathEncMapUint64IntR, (*decFnInfo).fastpathDecMapUint64IntR)
-	fn(map[uint64]int8(nil), (*encFnInfo).fastpathEncMapUint64Int8R, (*decFnInfo).fastpathDecMapUint64Int8R)
-	fn(map[uint64]int16(nil), (*encFnInfo).fastpathEncMapUint64Int16R, (*decFnInfo).fastpathDecMapUint64Int16R)
-	fn(map[uint64]int32(nil), (*encFnInfo).fastpathEncMapUint64Int32R, (*decFnInfo).fastpathDecMapUint64Int32R)
-	fn(map[uint64]int64(nil), (*encFnInfo).fastpathEncMapUint64Int64R, (*decFnInfo).fastpathDecMapUint64Int64R)
-	fn(map[uint64]float32(nil), (*encFnInfo).fastpathEncMapUint64Float32R, (*decFnInfo).fastpathDecMapUint64Float32R)
-	fn(map[uint64]float64(nil), (*encFnInfo).fastpathEncMapUint64Float64R, (*decFnInfo).fastpathDecMapUint64Float64R)
-	fn(map[uint64]bool(nil), (*encFnInfo).fastpathEncMapUint64BoolR, (*decFnInfo).fastpathDecMapUint64BoolR)
-	fn(map[uintptr]interface{}(nil), (*encFnInfo).fastpathEncMapUintptrIntfR, (*decFnInfo).fastpathDecMapUintptrIntfR)
-	fn(map[uintptr]string(nil), (*encFnInfo).fastpathEncMapUintptrStringR, (*decFnInfo).fastpathDecMapUintptrStringR)
-	fn(map[uintptr]uint(nil), (*encFnInfo).fastpathEncMapUintptrUintR, (*decFnInfo).fastpathDecMapUintptrUintR)
-	fn(map[uintptr]uint8(nil), (*encFnInfo).fastpathEncMapUintptrUint8R, (*decFnInfo).fastpathDecMapUintptrUint8R)
-	fn(map[uintptr]uint16(nil), (*encFnInfo).fastpathEncMapUintptrUint16R, (*decFnInfo).fastpathDecMapUintptrUint16R)
-	fn(map[uintptr]uint32(nil), (*encFnInfo).fastpathEncMapUintptrUint32R, (*decFnInfo).fastpathDecMapUintptrUint32R)
-	fn(map[uintptr]uint64(nil), (*encFnInfo).fastpathEncMapUintptrUint64R, (*decFnInfo).fastpathDecMapUintptrUint64R)
-	fn(map[uintptr]uintptr(nil), (*encFnInfo).fastpathEncMapUintptrUintptrR, (*decFnInfo).fastpathDecMapUintptrUintptrR)
-	fn(map[uintptr]int(nil), (*encFnInfo).fastpathEncMapUintptrIntR, (*decFnInfo).fastpathDecMapUintptrIntR)
-	fn(map[uintptr]int8(nil), (*encFnInfo).fastpathEncMapUintptrInt8R, (*decFnInfo).fastpathDecMapUintptrInt8R)
-	fn(map[uintptr]int16(nil), (*encFnInfo).fastpathEncMapUintptrInt16R, (*decFnInfo).fastpathDecMapUintptrInt16R)
-	fn(map[uintptr]int32(nil), (*encFnInfo).fastpathEncMapUintptrInt32R, (*decFnInfo).fastpathDecMapUintptrInt32R)
-	fn(map[uintptr]int64(nil), (*encFnInfo).fastpathEncMapUintptrInt64R, (*decFnInfo).fastpathDecMapUintptrInt64R)
-	fn(map[uintptr]float32(nil), (*encFnInfo).fastpathEncMapUintptrFloat32R, (*decFnInfo).fastpathDecMapUintptrFloat32R)
-	fn(map[uintptr]float64(nil), (*encFnInfo).fastpathEncMapUintptrFloat64R, (*decFnInfo).fastpathDecMapUintptrFloat64R)
-	fn(map[uintptr]bool(nil), (*encFnInfo).fastpathEncMapUintptrBoolR, (*decFnInfo).fastpathDecMapUintptrBoolR)
-	fn(map[int]interface{}(nil), (*encFnInfo).fastpathEncMapIntIntfR, (*decFnInfo).fastpathDecMapIntIntfR)
-	fn(map[int]string(nil), (*encFnInfo).fastpathEncMapIntStringR, (*decFnInfo).fastpathDecMapIntStringR)
-	fn(map[int]uint(nil), (*encFnInfo).fastpathEncMapIntUintR, (*decFnInfo).fastpathDecMapIntUintR)
-	fn(map[int]uint8(nil), (*encFnInfo).fastpathEncMapIntUint8R, (*decFnInfo).fastpathDecMapIntUint8R)
-	fn(map[int]uint16(nil), (*encFnInfo).fastpathEncMapIntUint16R, (*decFnInfo).fastpathDecMapIntUint16R)
-	fn(map[int]uint32(nil), (*encFnInfo).fastpathEncMapIntUint32R, (*decFnInfo).fastpathDecMapIntUint32R)
-	fn(map[int]uint64(nil), (*encFnInfo).fastpathEncMapIntUint64R, (*decFnInfo).fastpathDecMapIntUint64R)
-	fn(map[int]uintptr(nil), (*encFnInfo).fastpathEncMapIntUintptrR, (*decFnInfo).fastpathDecMapIntUintptrR)
-	fn(map[int]int(nil), (*encFnInfo).fastpathEncMapIntIntR, (*decFnInfo).fastpathDecMapIntIntR)
-	fn(map[int]int8(nil), (*encFnInfo).fastpathEncMapIntInt8R, (*decFnInfo).fastpathDecMapIntInt8R)
-	fn(map[int]int16(nil), (*encFnInfo).fastpathEncMapIntInt16R, (*decFnInfo).fastpathDecMapIntInt16R)
-	fn(map[int]int32(nil), (*encFnInfo).fastpathEncMapIntInt32R, (*decFnInfo).fastpathDecMapIntInt32R)
-	fn(map[int]int64(nil), (*encFnInfo).fastpathEncMapIntInt64R, (*decFnInfo).fastpathDecMapIntInt64R)
-	fn(map[int]float32(nil), (*encFnInfo).fastpathEncMapIntFloat32R, (*decFnInfo).fastpathDecMapIntFloat32R)
-	fn(map[int]float64(nil), (*encFnInfo).fastpathEncMapIntFloat64R, (*decFnInfo).fastpathDecMapIntFloat64R)
-	fn(map[int]bool(nil), (*encFnInfo).fastpathEncMapIntBoolR, (*decFnInfo).fastpathDecMapIntBoolR)
-	fn(map[int8]interface{}(nil), (*encFnInfo).fastpathEncMapInt8IntfR, (*decFnInfo).fastpathDecMapInt8IntfR)
-	fn(map[int8]string(nil), (*encFnInfo).fastpathEncMapInt8StringR, (*decFnInfo).fastpathDecMapInt8StringR)
-	fn(map[int8]uint(nil), (*encFnInfo).fastpathEncMapInt8UintR, (*decFnInfo).fastpathDecMapInt8UintR)
-	fn(map[int8]uint8(nil), (*encFnInfo).fastpathEncMapInt8Uint8R, (*decFnInfo).fastpathDecMapInt8Uint8R)
-	fn(map[int8]uint16(nil), (*encFnInfo).fastpathEncMapInt8Uint16R, (*decFnInfo).fastpathDecMapInt8Uint16R)
-	fn(map[int8]uint32(nil), (*encFnInfo).fastpathEncMapInt8Uint32R, (*decFnInfo).fastpathDecMapInt8Uint32R)
-	fn(map[int8]uint64(nil), (*encFnInfo).fastpathEncMapInt8Uint64R, (*decFnInfo).fastpathDecMapInt8Uint64R)
-	fn(map[int8]uintptr(nil), (*encFnInfo).fastpathEncMapInt8UintptrR, (*decFnInfo).fastpathDecMapInt8UintptrR)
-	fn(map[int8]int(nil), (*encFnInfo).fastpathEncMapInt8IntR, (*decFnInfo).fastpathDecMapInt8IntR)
-	fn(map[int8]int8(nil), (*encFnInfo).fastpathEncMapInt8Int8R, (*decFnInfo).fastpathDecMapInt8Int8R)
-	fn(map[int8]int16(nil), (*encFnInfo).fastpathEncMapInt8Int16R, (*decFnInfo).fastpathDecMapInt8Int16R)
-	fn(map[int8]int32(nil), (*encFnInfo).fastpathEncMapInt8Int32R, (*decFnInfo).fastpathDecMapInt8Int32R)
-	fn(map[int8]int64(nil), (*encFnInfo).fastpathEncMapInt8Int64R, (*decFnInfo).fastpathDecMapInt8Int64R)
-	fn(map[int8]float32(nil), (*encFnInfo).fastpathEncMapInt8Float32R, (*decFnInfo).fastpathDecMapInt8Float32R)
-	fn(map[int8]float64(nil), (*encFnInfo).fastpathEncMapInt8Float64R, (*decFnInfo).fastpathDecMapInt8Float64R)
-	fn(map[int8]bool(nil), (*encFnInfo).fastpathEncMapInt8BoolR, (*decFnInfo).fastpathDecMapInt8BoolR)
-	fn(map[int16]interface{}(nil), (*encFnInfo).fastpathEncMapInt16IntfR, (*decFnInfo).fastpathDecMapInt16IntfR)
-	fn(map[int16]string(nil), (*encFnInfo).fastpathEncMapInt16StringR, (*decFnInfo).fastpathDecMapInt16StringR)
-	fn(map[int16]uint(nil), (*encFnInfo).fastpathEncMapInt16UintR, (*decFnInfo).fastpathDecMapInt16UintR)
-	fn(map[int16]uint8(nil), (*encFnInfo).fastpathEncMapInt16Uint8R, (*decFnInfo).fastpathDecMapInt16Uint8R)
-	fn(map[int16]uint16(nil), (*encFnInfo).fastpathEncMapInt16Uint16R, (*decFnInfo).fastpathDecMapInt16Uint16R)
-	fn(map[int16]uint32(nil), (*encFnInfo).fastpathEncMapInt16Uint32R, (*decFnInfo).fastpathDecMapInt16Uint32R)
-	fn(map[int16]uint64(nil), (*encFnInfo).fastpathEncMapInt16Uint64R, (*decFnInfo).fastpathDecMapInt16Uint64R)
-	fn(map[int16]uintptr(nil), (*encFnInfo).fastpathEncMapInt16UintptrR, (*decFnInfo).fastpathDecMapInt16UintptrR)
-	fn(map[int16]int(nil), (*encFnInfo).fastpathEncMapInt16IntR, (*decFnInfo).fastpathDecMapInt16IntR)
-	fn(map[int16]int8(nil), (*encFnInfo).fastpathEncMapInt16Int8R, (*decFnInfo).fastpathDecMapInt16Int8R)
-	fn(map[int16]int16(nil), (*encFnInfo).fastpathEncMapInt16Int16R, (*decFnInfo).fastpathDecMapInt16Int16R)
-	fn(map[int16]int32(nil), (*encFnInfo).fastpathEncMapInt16Int32R, (*decFnInfo).fastpathDecMapInt16Int32R)
-	fn(map[int16]int64(nil), (*encFnInfo).fastpathEncMapInt16Int64R, (*decFnInfo).fastpathDecMapInt16Int64R)
-	fn(map[int16]float32(nil), (*encFnInfo).fastpathEncMapInt16Float32R, (*decFnInfo).fastpathDecMapInt16Float32R)
-	fn(map[int16]float64(nil), (*encFnInfo).fastpathEncMapInt16Float64R, (*decFnInfo).fastpathDecMapInt16Float64R)
-	fn(map[int16]bool(nil), (*encFnInfo).fastpathEncMapInt16BoolR, (*decFnInfo).fastpathDecMapInt16BoolR)
-	fn(map[int32]interface{}(nil), (*encFnInfo).fastpathEncMapInt32IntfR, (*decFnInfo).fastpathDecMapInt32IntfR)
-	fn(map[int32]string(nil), (*encFnInfo).fastpathEncMapInt32StringR, (*decFnInfo).fastpathDecMapInt32StringR)
-	fn(map[int32]uint(nil), (*encFnInfo).fastpathEncMapInt32UintR, (*decFnInfo).fastpathDecMapInt32UintR)
-	fn(map[int32]uint8(nil), (*encFnInfo).fastpathEncMapInt32Uint8R, (*decFnInfo).fastpathDecMapInt32Uint8R)
-	fn(map[int32]uint16(nil), (*encFnInfo).fastpathEncMapInt32Uint16R, (*decFnInfo).fastpathDecMapInt32Uint16R)
-	fn(map[int32]uint32(nil), (*encFnInfo).fastpathEncMapInt32Uint32R, (*decFnInfo).fastpathDecMapInt32Uint32R)
-	fn(map[int32]uint64(nil), (*encFnInfo).fastpathEncMapInt32Uint64R, (*decFnInfo).fastpathDecMapInt32Uint64R)
-	fn(map[int32]uintptr(nil), (*encFnInfo).fastpathEncMapInt32UintptrR, (*decFnInfo).fastpathDecMapInt32UintptrR)
-	fn(map[int32]int(nil), (*encFnInfo).fastpathEncMapInt32IntR, (*decFnInfo).fastpathDecMapInt32IntR)
-	fn(map[int32]int8(nil), (*encFnInfo).fastpathEncMapInt32Int8R, (*decFnInfo).fastpathDecMapInt32Int8R)
-	fn(map[int32]int16(nil), (*encFnInfo).fastpathEncMapInt32Int16R, (*decFnInfo).fastpathDecMapInt32Int16R)
-	fn(map[int32]int32(nil), (*encFnInfo).fastpathEncMapInt32Int32R, (*decFnInfo).fastpathDecMapInt32Int32R)
-	fn(map[int32]int64(nil), (*encFnInfo).fastpathEncMapInt32Int64R, (*decFnInfo).fastpathDecMapInt32Int64R)
-	fn(map[int32]float32(nil), (*encFnInfo).fastpathEncMapInt32Float32R, (*decFnInfo).fastpathDecMapInt32Float32R)
-	fn(map[int32]float64(nil), (*encFnInfo).fastpathEncMapInt32Float64R, (*decFnInfo).fastpathDecMapInt32Float64R)
-	fn(map[int32]bool(nil), (*encFnInfo).fastpathEncMapInt32BoolR, (*decFnInfo).fastpathDecMapInt32BoolR)
-	fn(map[int64]interface{}(nil), (*encFnInfo).fastpathEncMapInt64IntfR, (*decFnInfo).fastpathDecMapInt64IntfR)
-	fn(map[int64]string(nil), (*encFnInfo).fastpathEncMapInt64StringR, (*decFnInfo).fastpathDecMapInt64StringR)
-	fn(map[int64]uint(nil), (*encFnInfo).fastpathEncMapInt64UintR, (*decFnInfo).fastpathDecMapInt64UintR)
-	fn(map[int64]uint8(nil), (*encFnInfo).fastpathEncMapInt64Uint8R, (*decFnInfo).fastpathDecMapInt64Uint8R)
-	fn(map[int64]uint16(nil), (*encFnInfo).fastpathEncMapInt64Uint16R, (*decFnInfo).fastpathDecMapInt64Uint16R)
-	fn(map[int64]uint32(nil), (*encFnInfo).fastpathEncMapInt64Uint32R, (*decFnInfo).fastpathDecMapInt64Uint32R)
-	fn(map[int64]uint64(nil), (*encFnInfo).fastpathEncMapInt64Uint64R, (*decFnInfo).fastpathDecMapInt64Uint64R)
-	fn(map[int64]uintptr(nil), (*encFnInfo).fastpathEncMapInt64UintptrR, (*decFnInfo).fastpathDecMapInt64UintptrR)
-	fn(map[int64]int(nil), (*encFnInfo).fastpathEncMapInt64IntR, (*decFnInfo).fastpathDecMapInt64IntR)
-	fn(map[int64]int8(nil), (*encFnInfo).fastpathEncMapInt64Int8R, (*decFnInfo).fastpathDecMapInt64Int8R)
-	fn(map[int64]int16(nil), (*encFnInfo).fastpathEncMapInt64Int16R, (*decFnInfo).fastpathDecMapInt64Int16R)
-	fn(map[int64]int32(nil), (*encFnInfo).fastpathEncMapInt64Int32R, (*decFnInfo).fastpathDecMapInt64Int32R)
-	fn(map[int64]int64(nil), (*encFnInfo).fastpathEncMapInt64Int64R, (*decFnInfo).fastpathDecMapInt64Int64R)
-	fn(map[int64]float32(nil), (*encFnInfo).fastpathEncMapInt64Float32R, (*decFnInfo).fastpathDecMapInt64Float32R)
-	fn(map[int64]float64(nil), (*encFnInfo).fastpathEncMapInt64Float64R, (*decFnInfo).fastpathDecMapInt64Float64R)
-	fn(map[int64]bool(nil), (*encFnInfo).fastpathEncMapInt64BoolR, (*decFnInfo).fastpathDecMapInt64BoolR)
-	fn(map[bool]interface{}(nil), (*encFnInfo).fastpathEncMapBoolIntfR, (*decFnInfo).fastpathDecMapBoolIntfR)
-	fn(map[bool]string(nil), (*encFnInfo).fastpathEncMapBoolStringR, (*decFnInfo).fastpathDecMapBoolStringR)
-	fn(map[bool]uint(nil), (*encFnInfo).fastpathEncMapBoolUintR, (*decFnInfo).fastpathDecMapBoolUintR)
-	fn(map[bool]uint8(nil), (*encFnInfo).fastpathEncMapBoolUint8R, (*decFnInfo).fastpathDecMapBoolUint8R)
-	fn(map[bool]uint16(nil), (*encFnInfo).fastpathEncMapBoolUint16R, (*decFnInfo).fastpathDecMapBoolUint16R)
-	fn(map[bool]uint32(nil), (*encFnInfo).fastpathEncMapBoolUint32R, (*decFnInfo).fastpathDecMapBoolUint32R)
-	fn(map[bool]uint64(nil), (*encFnInfo).fastpathEncMapBoolUint64R, (*decFnInfo).fastpathDecMapBoolUint64R)
-	fn(map[bool]uintptr(nil), (*encFnInfo).fastpathEncMapBoolUintptrR, (*decFnInfo).fastpathDecMapBoolUintptrR)
-	fn(map[bool]int(nil), (*encFnInfo).fastpathEncMapBoolIntR, (*decFnInfo).fastpathDecMapBoolIntR)
-	fn(map[bool]int8(nil), (*encFnInfo).fastpathEncMapBoolInt8R, (*decFnInfo).fastpathDecMapBoolInt8R)
-	fn(map[bool]int16(nil), (*encFnInfo).fastpathEncMapBoolInt16R, (*decFnInfo).fastpathDecMapBoolInt16R)
-	fn(map[bool]int32(nil), (*encFnInfo).fastpathEncMapBoolInt32R, (*decFnInfo).fastpathDecMapBoolInt32R)
-	fn(map[bool]int64(nil), (*encFnInfo).fastpathEncMapBoolInt64R, (*decFnInfo).fastpathDecMapBoolInt64R)
-	fn(map[bool]float32(nil), (*encFnInfo).fastpathEncMapBoolFloat32R, (*decFnInfo).fastpathDecMapBoolFloat32R)
-	fn(map[bool]float64(nil), (*encFnInfo).fastpathEncMapBoolFloat64R, (*decFnInfo).fastpathDecMapBoolFloat64R)
-	fn(map[bool]bool(nil), (*encFnInfo).fastpathEncMapBoolBoolR, (*decFnInfo).fastpathDecMapBoolBoolR)
+	fn(map[interface{}]interface{}(nil), (*Encoder).fastpathEncMapIntfIntfR, (*Decoder).fastpathDecMapIntfIntfR)
+	fn(map[interface{}]string(nil), (*Encoder).fastpathEncMapIntfStringR, (*Decoder).fastpathDecMapIntfStringR)
+	fn(map[interface{}]uint(nil), (*Encoder).fastpathEncMapIntfUintR, (*Decoder).fastpathDecMapIntfUintR)
+	fn(map[interface{}]uint8(nil), (*Encoder).fastpathEncMapIntfUint8R, (*Decoder).fastpathDecMapIntfUint8R)
+	fn(map[interface{}]uint16(nil), (*Encoder).fastpathEncMapIntfUint16R, (*Decoder).fastpathDecMapIntfUint16R)
+	fn(map[interface{}]uint32(nil), (*Encoder).fastpathEncMapIntfUint32R, (*Decoder).fastpathDecMapIntfUint32R)
+	fn(map[interface{}]uint64(nil), (*Encoder).fastpathEncMapIntfUint64R, (*Decoder).fastpathDecMapIntfUint64R)
+	fn(map[interface{}]uintptr(nil), (*Encoder).fastpathEncMapIntfUintptrR, (*Decoder).fastpathDecMapIntfUintptrR)
+	fn(map[interface{}]int(nil), (*Encoder).fastpathEncMapIntfIntR, (*Decoder).fastpathDecMapIntfIntR)
+	fn(map[interface{}]int8(nil), (*Encoder).fastpathEncMapIntfInt8R, (*Decoder).fastpathDecMapIntfInt8R)
+	fn(map[interface{}]int16(nil), (*Encoder).fastpathEncMapIntfInt16R, (*Decoder).fastpathDecMapIntfInt16R)
+	fn(map[interface{}]int32(nil), (*Encoder).fastpathEncMapIntfInt32R, (*Decoder).fastpathDecMapIntfInt32R)
+	fn(map[interface{}]int64(nil), (*Encoder).fastpathEncMapIntfInt64R, (*Decoder).fastpathDecMapIntfInt64R)
+	fn(map[interface{}]float32(nil), (*Encoder).fastpathEncMapIntfFloat32R, (*Decoder).fastpathDecMapIntfFloat32R)
+	fn(map[interface{}]float64(nil), (*Encoder).fastpathEncMapIntfFloat64R, (*Decoder).fastpathDecMapIntfFloat64R)
+	fn(map[interface{}]bool(nil), (*Encoder).fastpathEncMapIntfBoolR, (*Decoder).fastpathDecMapIntfBoolR)
+	fn(map[string]interface{}(nil), (*Encoder).fastpathEncMapStringIntfR, (*Decoder).fastpathDecMapStringIntfR)
+	fn(map[string]string(nil), (*Encoder).fastpathEncMapStringStringR, (*Decoder).fastpathDecMapStringStringR)
+	fn(map[string]uint(nil), (*Encoder).fastpathEncMapStringUintR, (*Decoder).fastpathDecMapStringUintR)
+	fn(map[string]uint8(nil), (*Encoder).fastpathEncMapStringUint8R, (*Decoder).fastpathDecMapStringUint8R)
+	fn(map[string]uint16(nil), (*Encoder).fastpathEncMapStringUint16R, (*Decoder).fastpathDecMapStringUint16R)
+	fn(map[string]uint32(nil), (*Encoder).fastpathEncMapStringUint32R, (*Decoder).fastpathDecMapStringUint32R)
+	fn(map[string]uint64(nil), (*Encoder).fastpathEncMapStringUint64R, (*Decoder).fastpathDecMapStringUint64R)
+	fn(map[string]uintptr(nil), (*Encoder).fastpathEncMapStringUintptrR, (*Decoder).fastpathDecMapStringUintptrR)
+	fn(map[string]int(nil), (*Encoder).fastpathEncMapStringIntR, (*Decoder).fastpathDecMapStringIntR)
+	fn(map[string]int8(nil), (*Encoder).fastpathEncMapStringInt8R, (*Decoder).fastpathDecMapStringInt8R)
+	fn(map[string]int16(nil), (*Encoder).fastpathEncMapStringInt16R, (*Decoder).fastpathDecMapStringInt16R)
+	fn(map[string]int32(nil), (*Encoder).fastpathEncMapStringInt32R, (*Decoder).fastpathDecMapStringInt32R)
+	fn(map[string]int64(nil), (*Encoder).fastpathEncMapStringInt64R, (*Decoder).fastpathDecMapStringInt64R)
+	fn(map[string]float32(nil), (*Encoder).fastpathEncMapStringFloat32R, (*Decoder).fastpathDecMapStringFloat32R)
+	fn(map[string]float64(nil), (*Encoder).fastpathEncMapStringFloat64R, (*Decoder).fastpathDecMapStringFloat64R)
+	fn(map[string]bool(nil), (*Encoder).fastpathEncMapStringBoolR, (*Decoder).fastpathDecMapStringBoolR)
+	fn(map[float32]interface{}(nil), (*Encoder).fastpathEncMapFloat32IntfR, (*Decoder).fastpathDecMapFloat32IntfR)
+	fn(map[float32]string(nil), (*Encoder).fastpathEncMapFloat32StringR, (*Decoder).fastpathDecMapFloat32StringR)
+	fn(map[float32]uint(nil), (*Encoder).fastpathEncMapFloat32UintR, (*Decoder).fastpathDecMapFloat32UintR)
+	fn(map[float32]uint8(nil), (*Encoder).fastpathEncMapFloat32Uint8R, (*Decoder).fastpathDecMapFloat32Uint8R)
+	fn(map[float32]uint16(nil), (*Encoder).fastpathEncMapFloat32Uint16R, (*Decoder).fastpathDecMapFloat32Uint16R)
+	fn(map[float32]uint32(nil), (*Encoder).fastpathEncMapFloat32Uint32R, (*Decoder).fastpathDecMapFloat32Uint32R)
+	fn(map[float32]uint64(nil), (*Encoder).fastpathEncMapFloat32Uint64R, (*Decoder).fastpathDecMapFloat32Uint64R)
+	fn(map[float32]uintptr(nil), (*Encoder).fastpathEncMapFloat32UintptrR, (*Decoder).fastpathDecMapFloat32UintptrR)
+	fn(map[float32]int(nil), (*Encoder).fastpathEncMapFloat32IntR, (*Decoder).fastpathDecMapFloat32IntR)
+	fn(map[float32]int8(nil), (*Encoder).fastpathEncMapFloat32Int8R, (*Decoder).fastpathDecMapFloat32Int8R)
+	fn(map[float32]int16(nil), (*Encoder).fastpathEncMapFloat32Int16R, (*Decoder).fastpathDecMapFloat32Int16R)
+	fn(map[float32]int32(nil), (*Encoder).fastpathEncMapFloat32Int32R, (*Decoder).fastpathDecMapFloat32Int32R)
+	fn(map[float32]int64(nil), (*Encoder).fastpathEncMapFloat32Int64R, (*Decoder).fastpathDecMapFloat32Int64R)
+	fn(map[float32]float32(nil), (*Encoder).fastpathEncMapFloat32Float32R, (*Decoder).fastpathDecMapFloat32Float32R)
+	fn(map[float32]float64(nil), (*Encoder).fastpathEncMapFloat32Float64R, (*Decoder).fastpathDecMapFloat32Float64R)
+	fn(map[float32]bool(nil), (*Encoder).fastpathEncMapFloat32BoolR, (*Decoder).fastpathDecMapFloat32BoolR)
+	fn(map[float64]interface{}(nil), (*Encoder).fastpathEncMapFloat64IntfR, (*Decoder).fastpathDecMapFloat64IntfR)
+	fn(map[float64]string(nil), (*Encoder).fastpathEncMapFloat64StringR, (*Decoder).fastpathDecMapFloat64StringR)
+	fn(map[float64]uint(nil), (*Encoder).fastpathEncMapFloat64UintR, (*Decoder).fastpathDecMapFloat64UintR)
+	fn(map[float64]uint8(nil), (*Encoder).fastpathEncMapFloat64Uint8R, (*Decoder).fastpathDecMapFloat64Uint8R)
+	fn(map[float64]uint16(nil), (*Encoder).fastpathEncMapFloat64Uint16R, (*Decoder).fastpathDecMapFloat64Uint16R)
+	fn(map[float64]uint32(nil), (*Encoder).fastpathEncMapFloat64Uint32R, (*Decoder).fastpathDecMapFloat64Uint32R)
+	fn(map[float64]uint64(nil), (*Encoder).fastpathEncMapFloat64Uint64R, (*Decoder).fastpathDecMapFloat64Uint64R)
+	fn(map[float64]uintptr(nil), (*Encoder).fastpathEncMapFloat64UintptrR, (*Decoder).fastpathDecMapFloat64UintptrR)
+	fn(map[float64]int(nil), (*Encoder).fastpathEncMapFloat64IntR, (*Decoder).fastpathDecMapFloat64IntR)
+	fn(map[float64]int8(nil), (*Encoder).fastpathEncMapFloat64Int8R, (*Decoder).fastpathDecMapFloat64Int8R)
+	fn(map[float64]int16(nil), (*Encoder).fastpathEncMapFloat64Int16R, (*Decoder).fastpathDecMapFloat64Int16R)
+	fn(map[float64]int32(nil), (*Encoder).fastpathEncMapFloat64Int32R, (*Decoder).fastpathDecMapFloat64Int32R)
+	fn(map[float64]int64(nil), (*Encoder).fastpathEncMapFloat64Int64R, (*Decoder).fastpathDecMapFloat64Int64R)
+	fn(map[float64]float32(nil), (*Encoder).fastpathEncMapFloat64Float32R, (*Decoder).fastpathDecMapFloat64Float32R)
+	fn(map[float64]float64(nil), (*Encoder).fastpathEncMapFloat64Float64R, (*Decoder).fastpathDecMapFloat64Float64R)
+	fn(map[float64]bool(nil), (*Encoder).fastpathEncMapFloat64BoolR, (*Decoder).fastpathDecMapFloat64BoolR)
+	fn(map[uint]interface{}(nil), (*Encoder).fastpathEncMapUintIntfR, (*Decoder).fastpathDecMapUintIntfR)
+	fn(map[uint]string(nil), (*Encoder).fastpathEncMapUintStringR, (*Decoder).fastpathDecMapUintStringR)
+	fn(map[uint]uint(nil), (*Encoder).fastpathEncMapUintUintR, (*Decoder).fastpathDecMapUintUintR)
+	fn(map[uint]uint8(nil), (*Encoder).fastpathEncMapUintUint8R, (*Decoder).fastpathDecMapUintUint8R)
+	fn(map[uint]uint16(nil), (*Encoder).fastpathEncMapUintUint16R, (*Decoder).fastpathDecMapUintUint16R)
+	fn(map[uint]uint32(nil), (*Encoder).fastpathEncMapUintUint32R, (*Decoder).fastpathDecMapUintUint32R)
+	fn(map[uint]uint64(nil), (*Encoder).fastpathEncMapUintUint64R, (*Decoder).fastpathDecMapUintUint64R)
+	fn(map[uint]uintptr(nil), (*Encoder).fastpathEncMapUintUintptrR, (*Decoder).fastpathDecMapUintUintptrR)
+	fn(map[uint]int(nil), (*Encoder).fastpathEncMapUintIntR, (*Decoder).fastpathDecMapUintIntR)
+	fn(map[uint]int8(nil), (*Encoder).fastpathEncMapUintInt8R, (*Decoder).fastpathDecMapUintInt8R)
+	fn(map[uint]int16(nil), (*Encoder).fastpathEncMapUintInt16R, (*Decoder).fastpathDecMapUintInt16R)
+	fn(map[uint]int32(nil), (*Encoder).fastpathEncMapUintInt32R, (*Decoder).fastpathDecMapUintInt32R)
+	fn(map[uint]int64(nil), (*Encoder).fastpathEncMapUintInt64R, (*Decoder).fastpathDecMapUintInt64R)
+	fn(map[uint]float32(nil), (*Encoder).fastpathEncMapUintFloat32R, (*Decoder).fastpathDecMapUintFloat32R)
+	fn(map[uint]float64(nil), (*Encoder).fastpathEncMapUintFloat64R, (*Decoder).fastpathDecMapUintFloat64R)
+	fn(map[uint]bool(nil), (*Encoder).fastpathEncMapUintBoolR, (*Decoder).fastpathDecMapUintBoolR)
+	fn(map[uint8]interface{}(nil), (*Encoder).fastpathEncMapUint8IntfR, (*Decoder).fastpathDecMapUint8IntfR)
+	fn(map[uint8]string(nil), (*Encoder).fastpathEncMapUint8StringR, (*Decoder).fastpathDecMapUint8StringR)
+	fn(map[uint8]uint(nil), (*Encoder).fastpathEncMapUint8UintR, (*Decoder).fastpathDecMapUint8UintR)
+	fn(map[uint8]uint8(nil), (*Encoder).fastpathEncMapUint8Uint8R, (*Decoder).fastpathDecMapUint8Uint8R)
+	fn(map[uint8]uint16(nil), (*Encoder).fastpathEncMapUint8Uint16R, (*Decoder).fastpathDecMapUint8Uint16R)
+	fn(map[uint8]uint32(nil), (*Encoder).fastpathEncMapUint8Uint32R, (*Decoder).fastpathDecMapUint8Uint32R)
+	fn(map[uint8]uint64(nil), (*Encoder).fastpathEncMapUint8Uint64R, (*Decoder).fastpathDecMapUint8Uint64R)
+	fn(map[uint8]uintptr(nil), (*Encoder).fastpathEncMapUint8UintptrR, (*Decoder).fastpathDecMapUint8UintptrR)
+	fn(map[uint8]int(nil), (*Encoder).fastpathEncMapUint8IntR, (*Decoder).fastpathDecMapUint8IntR)
+	fn(map[uint8]int8(nil), (*Encoder).fastpathEncMapUint8Int8R, (*Decoder).fastpathDecMapUint8Int8R)
+	fn(map[uint8]int16(nil), (*Encoder).fastpathEncMapUint8Int16R, (*Decoder).fastpathDecMapUint8Int16R)
+	fn(map[uint8]int32(nil), (*Encoder).fastpathEncMapUint8Int32R, (*Decoder).fastpathDecMapUint8Int32R)
+	fn(map[uint8]int64(nil), (*Encoder).fastpathEncMapUint8Int64R, (*Decoder).fastpathDecMapUint8Int64R)
+	fn(map[uint8]float32(nil), (*Encoder).fastpathEncMapUint8Float32R, (*Decoder).fastpathDecMapUint8Float32R)
+	fn(map[uint8]float64(nil), (*Encoder).fastpathEncMapUint8Float64R, (*Decoder).fastpathDecMapUint8Float64R)
+	fn(map[uint8]bool(nil), (*Encoder).fastpathEncMapUint8BoolR, (*Decoder).fastpathDecMapUint8BoolR)
+	fn(map[uint16]interface{}(nil), (*Encoder).fastpathEncMapUint16IntfR, (*Decoder).fastpathDecMapUint16IntfR)
+	fn(map[uint16]string(nil), (*Encoder).fastpathEncMapUint16StringR, (*Decoder).fastpathDecMapUint16StringR)
+	fn(map[uint16]uint(nil), (*Encoder).fastpathEncMapUint16UintR, (*Decoder).fastpathDecMapUint16UintR)
+	fn(map[uint16]uint8(nil), (*Encoder).fastpathEncMapUint16Uint8R, (*Decoder).fastpathDecMapUint16Uint8R)
+	fn(map[uint16]uint16(nil), (*Encoder).fastpathEncMapUint16Uint16R, (*Decoder).fastpathDecMapUint16Uint16R)
+	fn(map[uint16]uint32(nil), (*Encoder).fastpathEncMapUint16Uint32R, (*Decoder).fastpathDecMapUint16Uint32R)
+	fn(map[uint16]uint64(nil), (*Encoder).fastpathEncMapUint16Uint64R, (*Decoder).fastpathDecMapUint16Uint64R)
+	fn(map[uint16]uintptr(nil), (*Encoder).fastpathEncMapUint16UintptrR, (*Decoder).fastpathDecMapUint16UintptrR)
+	fn(map[uint16]int(nil), (*Encoder).fastpathEncMapUint16IntR, (*Decoder).fastpathDecMapUint16IntR)
+	fn(map[uint16]int8(nil), (*Encoder).fastpathEncMapUint16Int8R, (*Decoder).fastpathDecMapUint16Int8R)
+	fn(map[uint16]int16(nil), (*Encoder).fastpathEncMapUint16Int16R, (*Decoder).fastpathDecMapUint16Int16R)
+	fn(map[uint16]int32(nil), (*Encoder).fastpathEncMapUint16Int32R, (*Decoder).fastpathDecMapUint16Int32R)
+	fn(map[uint16]int64(nil), (*Encoder).fastpathEncMapUint16Int64R, (*Decoder).fastpathDecMapUint16Int64R)
+	fn(map[uint16]float32(nil), (*Encoder).fastpathEncMapUint16Float32R, (*Decoder).fastpathDecMapUint16Float32R)
+	fn(map[uint16]float64(nil), (*Encoder).fastpathEncMapUint16Float64R, (*Decoder).fastpathDecMapUint16Float64R)
+	fn(map[uint16]bool(nil), (*Encoder).fastpathEncMapUint16BoolR, (*Decoder).fastpathDecMapUint16BoolR)
+	fn(map[uint32]interface{}(nil), (*Encoder).fastpathEncMapUint32IntfR, (*Decoder).fastpathDecMapUint32IntfR)
+	fn(map[uint32]string(nil), (*Encoder).fastpathEncMapUint32StringR, (*Decoder).fastpathDecMapUint32StringR)
+	fn(map[uint32]uint(nil), (*Encoder).fastpathEncMapUint32UintR, (*Decoder).fastpathDecMapUint32UintR)
+	fn(map[uint32]uint8(nil), (*Encoder).fastpathEncMapUint32Uint8R, (*Decoder).fastpathDecMapUint32Uint8R)
+	fn(map[uint32]uint16(nil), (*Encoder).fastpathEncMapUint32Uint16R, (*Decoder).fastpathDecMapUint32Uint16R)
+	fn(map[uint32]uint32(nil), (*Encoder).fastpathEncMapUint32Uint32R, (*Decoder).fastpathDecMapUint32Uint32R)
+	fn(map[uint32]uint64(nil), (*Encoder).fastpathEncMapUint32Uint64R, (*Decoder).fastpathDecMapUint32Uint64R)
+	fn(map[uint32]uintptr(nil), (*Encoder).fastpathEncMapUint32UintptrR, (*Decoder).fastpathDecMapUint32UintptrR)
+	fn(map[uint32]int(nil), (*Encoder).fastpathEncMapUint32IntR, (*Decoder).fastpathDecMapUint32IntR)
+	fn(map[uint32]int8(nil), (*Encoder).fastpathEncMapUint32Int8R, (*Decoder).fastpathDecMapUint32Int8R)
+	fn(map[uint32]int16(nil), (*Encoder).fastpathEncMapUint32Int16R, (*Decoder).fastpathDecMapUint32Int16R)
+	fn(map[uint32]int32(nil), (*Encoder).fastpathEncMapUint32Int32R, (*Decoder).fastpathDecMapUint32Int32R)
+	fn(map[uint32]int64(nil), (*Encoder).fastpathEncMapUint32Int64R, (*Decoder).fastpathDecMapUint32Int64R)
+	fn(map[uint32]float32(nil), (*Encoder).fastpathEncMapUint32Float32R, (*Decoder).fastpathDecMapUint32Float32R)
+	fn(map[uint32]float64(nil), (*Encoder).fastpathEncMapUint32Float64R, (*Decoder).fastpathDecMapUint32Float64R)
+	fn(map[uint32]bool(nil), (*Encoder).fastpathEncMapUint32BoolR, (*Decoder).fastpathDecMapUint32BoolR)
+	fn(map[uint64]interface{}(nil), (*Encoder).fastpathEncMapUint64IntfR, (*Decoder).fastpathDecMapUint64IntfR)
+	fn(map[uint64]string(nil), (*Encoder).fastpathEncMapUint64StringR, (*Decoder).fastpathDecMapUint64StringR)
+	fn(map[uint64]uint(nil), (*Encoder).fastpathEncMapUint64UintR, (*Decoder).fastpathDecMapUint64UintR)
+	fn(map[uint64]uint8(nil), (*Encoder).fastpathEncMapUint64Uint8R, (*Decoder).fastpathDecMapUint64Uint8R)
+	fn(map[uint64]uint16(nil), (*Encoder).fastpathEncMapUint64Uint16R, (*Decoder).fastpathDecMapUint64Uint16R)
+	fn(map[uint64]uint32(nil), (*Encoder).fastpathEncMapUint64Uint32R, (*Decoder).fastpathDecMapUint64Uint32R)
+	fn(map[uint64]uint64(nil), (*Encoder).fastpathEncMapUint64Uint64R, (*Decoder).fastpathDecMapUint64Uint64R)
+	fn(map[uint64]uintptr(nil), (*Encoder).fastpathEncMapUint64UintptrR, (*Decoder).fastpathDecMapUint64UintptrR)
+	fn(map[uint64]int(nil), (*Encoder).fastpathEncMapUint64IntR, (*Decoder).fastpathDecMapUint64IntR)
+	fn(map[uint64]int8(nil), (*Encoder).fastpathEncMapUint64Int8R, (*Decoder).fastpathDecMapUint64Int8R)
+	fn(map[uint64]int16(nil), (*Encoder).fastpathEncMapUint64Int16R, (*Decoder).fastpathDecMapUint64Int16R)
+	fn(map[uint64]int32(nil), (*Encoder).fastpathEncMapUint64Int32R, (*Decoder).fastpathDecMapUint64Int32R)
+	fn(map[uint64]int64(nil), (*Encoder).fastpathEncMapUint64Int64R, (*Decoder).fastpathDecMapUint64Int64R)
+	fn(map[uint64]float32(nil), (*Encoder).fastpathEncMapUint64Float32R, (*Decoder).fastpathDecMapUint64Float32R)
+	fn(map[uint64]float64(nil), (*Encoder).fastpathEncMapUint64Float64R, (*Decoder).fastpathDecMapUint64Float64R)
+	fn(map[uint64]bool(nil), (*Encoder).fastpathEncMapUint64BoolR, (*Decoder).fastpathDecMapUint64BoolR)
+	fn(map[uintptr]interface{}(nil), (*Encoder).fastpathEncMapUintptrIntfR, (*Decoder).fastpathDecMapUintptrIntfR)
+	fn(map[uintptr]string(nil), (*Encoder).fastpathEncMapUintptrStringR, (*Decoder).fastpathDecMapUintptrStringR)
+	fn(map[uintptr]uint(nil), (*Encoder).fastpathEncMapUintptrUintR, (*Decoder).fastpathDecMapUintptrUintR)
+	fn(map[uintptr]uint8(nil), (*Encoder).fastpathEncMapUintptrUint8R, (*Decoder).fastpathDecMapUintptrUint8R)
+	fn(map[uintptr]uint16(nil), (*Encoder).fastpathEncMapUintptrUint16R, (*Decoder).fastpathDecMapUintptrUint16R)
+	fn(map[uintptr]uint32(nil), (*Encoder).fastpathEncMapUintptrUint32R, (*Decoder).fastpathDecMapUintptrUint32R)
+	fn(map[uintptr]uint64(nil), (*Encoder).fastpathEncMapUintptrUint64R, (*Decoder).fastpathDecMapUintptrUint64R)
+	fn(map[uintptr]uintptr(nil), (*Encoder).fastpathEncMapUintptrUintptrR, (*Decoder).fastpathDecMapUintptrUintptrR)
+	fn(map[uintptr]int(nil), (*Encoder).fastpathEncMapUintptrIntR, (*Decoder).fastpathDecMapUintptrIntR)
+	fn(map[uintptr]int8(nil), (*Encoder).fastpathEncMapUintptrInt8R, (*Decoder).fastpathDecMapUintptrInt8R)
+	fn(map[uintptr]int16(nil), (*Encoder).fastpathEncMapUintptrInt16R, (*Decoder).fastpathDecMapUintptrInt16R)
+	fn(map[uintptr]int32(nil), (*Encoder).fastpathEncMapUintptrInt32R, (*Decoder).fastpathDecMapUintptrInt32R)
+	fn(map[uintptr]int64(nil), (*Encoder).fastpathEncMapUintptrInt64R, (*Decoder).fastpathDecMapUintptrInt64R)
+	fn(map[uintptr]float32(nil), (*Encoder).fastpathEncMapUintptrFloat32R, (*Decoder).fastpathDecMapUintptrFloat32R)
+	fn(map[uintptr]float64(nil), (*Encoder).fastpathEncMapUintptrFloat64R, (*Decoder).fastpathDecMapUintptrFloat64R)
+	fn(map[uintptr]bool(nil), (*Encoder).fastpathEncMapUintptrBoolR, (*Decoder).fastpathDecMapUintptrBoolR)
+	fn(map[int]interface{}(nil), (*Encoder).fastpathEncMapIntIntfR, (*Decoder).fastpathDecMapIntIntfR)
+	fn(map[int]string(nil), (*Encoder).fastpathEncMapIntStringR, (*Decoder).fastpathDecMapIntStringR)
+	fn(map[int]uint(nil), (*Encoder).fastpathEncMapIntUintR, (*Decoder).fastpathDecMapIntUintR)
+	fn(map[int]uint8(nil), (*Encoder).fastpathEncMapIntUint8R, (*Decoder).fastpathDecMapIntUint8R)
+	fn(map[int]uint16(nil), (*Encoder).fastpathEncMapIntUint16R, (*Decoder).fastpathDecMapIntUint16R)
+	fn(map[int]uint32(nil), (*Encoder).fastpathEncMapIntUint32R, (*Decoder).fastpathDecMapIntUint32R)
+	fn(map[int]uint64(nil), (*Encoder).fastpathEncMapIntUint64R, (*Decoder).fastpathDecMapIntUint64R)
+	fn(map[int]uintptr(nil), (*Encoder).fastpathEncMapIntUintptrR, (*Decoder).fastpathDecMapIntUintptrR)
+	fn(map[int]int(nil), (*Encoder).fastpathEncMapIntIntR, (*Decoder).fastpathDecMapIntIntR)
+	fn(map[int]int8(nil), (*Encoder).fastpathEncMapIntInt8R, (*Decoder).fastpathDecMapIntInt8R)
+	fn(map[int]int16(nil), (*Encoder).fastpathEncMapIntInt16R, (*Decoder).fastpathDecMapIntInt16R)
+	fn(map[int]int32(nil), (*Encoder).fastpathEncMapIntInt32R, (*Decoder).fastpathDecMapIntInt32R)
+	fn(map[int]int64(nil), (*Encoder).fastpathEncMapIntInt64R, (*Decoder).fastpathDecMapIntInt64R)
+	fn(map[int]float32(nil), (*Encoder).fastpathEncMapIntFloat32R, (*Decoder).fastpathDecMapIntFloat32R)
+	fn(map[int]float64(nil), (*Encoder).fastpathEncMapIntFloat64R, (*Decoder).fastpathDecMapIntFloat64R)
+	fn(map[int]bool(nil), (*Encoder).fastpathEncMapIntBoolR, (*Decoder).fastpathDecMapIntBoolR)
+	fn(map[int8]interface{}(nil), (*Encoder).fastpathEncMapInt8IntfR, (*Decoder).fastpathDecMapInt8IntfR)
+	fn(map[int8]string(nil), (*Encoder).fastpathEncMapInt8StringR, (*Decoder).fastpathDecMapInt8StringR)
+	fn(map[int8]uint(nil), (*Encoder).fastpathEncMapInt8UintR, (*Decoder).fastpathDecMapInt8UintR)
+	fn(map[int8]uint8(nil), (*Encoder).fastpathEncMapInt8Uint8R, (*Decoder).fastpathDecMapInt8Uint8R)
+	fn(map[int8]uint16(nil), (*Encoder).fastpathEncMapInt8Uint16R, (*Decoder).fastpathDecMapInt8Uint16R)
+	fn(map[int8]uint32(nil), (*Encoder).fastpathEncMapInt8Uint32R, (*Decoder).fastpathDecMapInt8Uint32R)
+	fn(map[int8]uint64(nil), (*Encoder).fastpathEncMapInt8Uint64R, (*Decoder).fastpathDecMapInt8Uint64R)
+	fn(map[int8]uintptr(nil), (*Encoder).fastpathEncMapInt8UintptrR, (*Decoder).fastpathDecMapInt8UintptrR)
+	fn(map[int8]int(nil), (*Encoder).fastpathEncMapInt8IntR, (*Decoder).fastpathDecMapInt8IntR)
+	fn(map[int8]int8(nil), (*Encoder).fastpathEncMapInt8Int8R, (*Decoder).fastpathDecMapInt8Int8R)
+	fn(map[int8]int16(nil), (*Encoder).fastpathEncMapInt8Int16R, (*Decoder).fastpathDecMapInt8Int16R)
+	fn(map[int8]int32(nil), (*Encoder).fastpathEncMapInt8Int32R, (*Decoder).fastpathDecMapInt8Int32R)
+	fn(map[int8]int64(nil), (*Encoder).fastpathEncMapInt8Int64R, (*Decoder).fastpathDecMapInt8Int64R)
+	fn(map[int8]float32(nil), (*Encoder).fastpathEncMapInt8Float32R, (*Decoder).fastpathDecMapInt8Float32R)
+	fn(map[int8]float64(nil), (*Encoder).fastpathEncMapInt8Float64R, (*Decoder).fastpathDecMapInt8Float64R)
+	fn(map[int8]bool(nil), (*Encoder).fastpathEncMapInt8BoolR, (*Decoder).fastpathDecMapInt8BoolR)
+	fn(map[int16]interface{}(nil), (*Encoder).fastpathEncMapInt16IntfR, (*Decoder).fastpathDecMapInt16IntfR)
+	fn(map[int16]string(nil), (*Encoder).fastpathEncMapInt16StringR, (*Decoder).fastpathDecMapInt16StringR)
+	fn(map[int16]uint(nil), (*Encoder).fastpathEncMapInt16UintR, (*Decoder).fastpathDecMapInt16UintR)
+	fn(map[int16]uint8(nil), (*Encoder).fastpathEncMapInt16Uint8R, (*Decoder).fastpathDecMapInt16Uint8R)
+	fn(map[int16]uint16(nil), (*Encoder).fastpathEncMapInt16Uint16R, (*Decoder).fastpathDecMapInt16Uint16R)
+	fn(map[int16]uint32(nil), (*Encoder).fastpathEncMapInt16Uint32R, (*Decoder).fastpathDecMapInt16Uint32R)
+	fn(map[int16]uint64(nil), (*Encoder).fastpathEncMapInt16Uint64R, (*Decoder).fastpathDecMapInt16Uint64R)
+	fn(map[int16]uintptr(nil), (*Encoder).fastpathEncMapInt16UintptrR, (*Decoder).fastpathDecMapInt16UintptrR)
+	fn(map[int16]int(nil), (*Encoder).fastpathEncMapInt16IntR, (*Decoder).fastpathDecMapInt16IntR)
+	fn(map[int16]int8(nil), (*Encoder).fastpathEncMapInt16Int8R, (*Decoder).fastpathDecMapInt16Int8R)
+	fn(map[int16]int16(nil), (*Encoder).fastpathEncMapInt16Int16R, (*Decoder).fastpathDecMapInt16Int16R)
+	fn(map[int16]int32(nil), (*Encoder).fastpathEncMapInt16Int32R, (*Decoder).fastpathDecMapInt16Int32R)
+	fn(map[int16]int64(nil), (*Encoder).fastpathEncMapInt16Int64R, (*Decoder).fastpathDecMapInt16Int64R)
+	fn(map[int16]float32(nil), (*Encoder).fastpathEncMapInt16Float32R, (*Decoder).fastpathDecMapInt16Float32R)
+	fn(map[int16]float64(nil), (*Encoder).fastpathEncMapInt16Float64R, (*Decoder).fastpathDecMapInt16Float64R)
+	fn(map[int16]bool(nil), (*Encoder).fastpathEncMapInt16BoolR, (*Decoder).fastpathDecMapInt16BoolR)
+	fn(map[int32]interface{}(nil), (*Encoder).fastpathEncMapInt32IntfR, (*Decoder).fastpathDecMapInt32IntfR)
+	fn(map[int32]string(nil), (*Encoder).fastpathEncMapInt32StringR, (*Decoder).fastpathDecMapInt32StringR)
+	fn(map[int32]uint(nil), (*Encoder).fastpathEncMapInt32UintR, (*Decoder).fastpathDecMapInt32UintR)
+	fn(map[int32]uint8(nil), (*Encoder).fastpathEncMapInt32Uint8R, (*Decoder).fastpathDecMapInt32Uint8R)
+	fn(map[int32]uint16(nil), (*Encoder).fastpathEncMapInt32Uint16R, (*Decoder).fastpathDecMapInt32Uint16R)
+	fn(map[int32]uint32(nil), (*Encoder).fastpathEncMapInt32Uint32R, (*Decoder).fastpathDecMapInt32Uint32R)
+	fn(map[int32]uint64(nil), (*Encoder).fastpathEncMapInt32Uint64R, (*Decoder).fastpathDecMapInt32Uint64R)
+	fn(map[int32]uintptr(nil), (*Encoder).fastpathEncMapInt32UintptrR, (*Decoder).fastpathDecMapInt32UintptrR)
+	fn(map[int32]int(nil), (*Encoder).fastpathEncMapInt32IntR, (*Decoder).fastpathDecMapInt32IntR)
+	fn(map[int32]int8(nil), (*Encoder).fastpathEncMapInt32Int8R, (*Decoder).fastpathDecMapInt32Int8R)
+	fn(map[int32]int16(nil), (*Encoder).fastpathEncMapInt32Int16R, (*Decoder).fastpathDecMapInt32Int16R)
+	fn(map[int32]int32(nil), (*Encoder).fastpathEncMapInt32Int32R, (*Decoder).fastpathDecMapInt32Int32R)
+	fn(map[int32]int64(nil), (*Encoder).fastpathEncMapInt32Int64R, (*Decoder).fastpathDecMapInt32Int64R)
+	fn(map[int32]float32(nil), (*Encoder).fastpathEncMapInt32Float32R, (*Decoder).fastpathDecMapInt32Float32R)
+	fn(map[int32]float64(nil), (*Encoder).fastpathEncMapInt32Float64R, (*Decoder).fastpathDecMapInt32Float64R)
+	fn(map[int32]bool(nil), (*Encoder).fastpathEncMapInt32BoolR, (*Decoder).fastpathDecMapInt32BoolR)
+	fn(map[int64]interface{}(nil), (*Encoder).fastpathEncMapInt64IntfR, (*Decoder).fastpathDecMapInt64IntfR)
+	fn(map[int64]string(nil), (*Encoder).fastpathEncMapInt64StringR, (*Decoder).fastpathDecMapInt64StringR)
+	fn(map[int64]uint(nil), (*Encoder).fastpathEncMapInt64UintR, (*Decoder).fastpathDecMapInt64UintR)
+	fn(map[int64]uint8(nil), (*Encoder).fastpathEncMapInt64Uint8R, (*Decoder).fastpathDecMapInt64Uint8R)
+	fn(map[int64]uint16(nil), (*Encoder).fastpathEncMapInt64Uint16R, (*Decoder).fastpathDecMapInt64Uint16R)
+	fn(map[int64]uint32(nil), (*Encoder).fastpathEncMapInt64Uint32R, (*Decoder).fastpathDecMapInt64Uint32R)
+	fn(map[int64]uint64(nil), (*Encoder).fastpathEncMapInt64Uint64R, (*Decoder).fastpathDecMapInt64Uint64R)
+	fn(map[int64]uintptr(nil), (*Encoder).fastpathEncMapInt64UintptrR, (*Decoder).fastpathDecMapInt64UintptrR)
+	fn(map[int64]int(nil), (*Encoder).fastpathEncMapInt64IntR, (*Decoder).fastpathDecMapInt64IntR)
+	fn(map[int64]int8(nil), (*Encoder).fastpathEncMapInt64Int8R, (*Decoder).fastpathDecMapInt64Int8R)
+	fn(map[int64]int16(nil), (*Encoder).fastpathEncMapInt64Int16R, (*Decoder).fastpathDecMapInt64Int16R)
+	fn(map[int64]int32(nil), (*Encoder).fastpathEncMapInt64Int32R, (*Decoder).fastpathDecMapInt64Int32R)
+	fn(map[int64]int64(nil), (*Encoder).fastpathEncMapInt64Int64R, (*Decoder).fastpathDecMapInt64Int64R)
+	fn(map[int64]float32(nil), (*Encoder).fastpathEncMapInt64Float32R, (*Decoder).fastpathDecMapInt64Float32R)
+	fn(map[int64]float64(nil), (*Encoder).fastpathEncMapInt64Float64R, (*Decoder).fastpathDecMapInt64Float64R)
+	fn(map[int64]bool(nil), (*Encoder).fastpathEncMapInt64BoolR, (*Decoder).fastpathDecMapInt64BoolR)
+	fn(map[bool]interface{}(nil), (*Encoder).fastpathEncMapBoolIntfR, (*Decoder).fastpathDecMapBoolIntfR)
+	fn(map[bool]string(nil), (*Encoder).fastpathEncMapBoolStringR, (*Decoder).fastpathDecMapBoolStringR)
+	fn(map[bool]uint(nil), (*Encoder).fastpathEncMapBoolUintR, (*Decoder).fastpathDecMapBoolUintR)
+	fn(map[bool]uint8(nil), (*Encoder).fastpathEncMapBoolUint8R, (*Decoder).fastpathDecMapBoolUint8R)
+	fn(map[bool]uint16(nil), (*Encoder).fastpathEncMapBoolUint16R, (*Decoder).fastpathDecMapBoolUint16R)
+	fn(map[bool]uint32(nil), (*Encoder).fastpathEncMapBoolUint32R, (*Decoder).fastpathDecMapBoolUint32R)
+	fn(map[bool]uint64(nil), (*Encoder).fastpathEncMapBoolUint64R, (*Decoder).fastpathDecMapBoolUint64R)
+	fn(map[bool]uintptr(nil), (*Encoder).fastpathEncMapBoolUintptrR, (*Decoder).fastpathDecMapBoolUintptrR)
+	fn(map[bool]int(nil), (*Encoder).fastpathEncMapBoolIntR, (*Decoder).fastpathDecMapBoolIntR)
+	fn(map[bool]int8(nil), (*Encoder).fastpathEncMapBoolInt8R, (*Decoder).fastpathDecMapBoolInt8R)
+	fn(map[bool]int16(nil), (*Encoder).fastpathEncMapBoolInt16R, (*Decoder).fastpathDecMapBoolInt16R)
+	fn(map[bool]int32(nil), (*Encoder).fastpathEncMapBoolInt32R, (*Decoder).fastpathDecMapBoolInt32R)
+	fn(map[bool]int64(nil), (*Encoder).fastpathEncMapBoolInt64R, (*Decoder).fastpathDecMapBoolInt64R)
+	fn(map[bool]float32(nil), (*Encoder).fastpathEncMapBoolFloat32R, (*Decoder).fastpathDecMapBoolFloat32R)
+	fn(map[bool]float64(nil), (*Encoder).fastpathEncMapBoolFloat64R, (*Decoder).fastpathDecMapBoolFloat64R)
+	fn(map[bool]bool(nil), (*Encoder).fastpathEncMapBoolBoolR, (*Decoder).fastpathDecMapBoolBoolR)
 
 	sort.Sort(fastpathAslice(fastpathAV[:]))
 }
@@ -375,2734 +371,1090 @@ func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool {
 	switch v := iv.(type) {
 
 	case []interface{}:
-		fastpathTV.EncSliceIntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceIntfV(v, e)
 	case *[]interface{}:
-		fastpathTV.EncSliceIntfV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncSliceIntfV(*v, e)
+	case []string:
+		fastpathTV.EncSliceStringV(v, e)
+	case *[]string:
+		fastpathTV.EncSliceStringV(*v, e)
+	case []float32:
+		fastpathTV.EncSliceFloat32V(v, e)
+	case *[]float32:
+		fastpathTV.EncSliceFloat32V(*v, e)
+	case []float64:
+		fastpathTV.EncSliceFloat64V(v, e)
+	case *[]float64:
+		fastpathTV.EncSliceFloat64V(*v, e)
+	case []uint:
+		fastpathTV.EncSliceUintV(v, e)
+	case *[]uint:
+		fastpathTV.EncSliceUintV(*v, e)
+	case []uint16:
+		fastpathTV.EncSliceUint16V(v, e)
+	case *[]uint16:
+		fastpathTV.EncSliceUint16V(*v, e)
+	case []uint32:
+		fastpathTV.EncSliceUint32V(v, e)
+	case *[]uint32:
+		fastpathTV.EncSliceUint32V(*v, e)
+	case []uint64:
+		fastpathTV.EncSliceUint64V(v, e)
+	case *[]uint64:
+		fastpathTV.EncSliceUint64V(*v, e)
+	case []uintptr:
+		fastpathTV.EncSliceUintptrV(v, e)
+	case *[]uintptr:
+		fastpathTV.EncSliceUintptrV(*v, e)
+	case []int:
+		fastpathTV.EncSliceIntV(v, e)
+	case *[]int:
+		fastpathTV.EncSliceIntV(*v, e)
+	case []int8:
+		fastpathTV.EncSliceInt8V(v, e)
+	case *[]int8:
+		fastpathTV.EncSliceInt8V(*v, e)
+	case []int16:
+		fastpathTV.EncSliceInt16V(v, e)
+	case *[]int16:
+		fastpathTV.EncSliceInt16V(*v, e)
+	case []int32:
+		fastpathTV.EncSliceInt32V(v, e)
+	case *[]int32:
+		fastpathTV.EncSliceInt32V(*v, e)
+	case []int64:
+		fastpathTV.EncSliceInt64V(v, e)
+	case *[]int64:
+		fastpathTV.EncSliceInt64V(*v, e)
+	case []bool:
+		fastpathTV.EncSliceBoolV(v, e)
+	case *[]bool:
+		fastpathTV.EncSliceBoolV(*v, e)
 
 	case map[interface{}]interface{}:
-		fastpathTV.EncMapIntfIntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfIntfV(v, e)
 	case *map[interface{}]interface{}:
-		fastpathTV.EncMapIntfIntfV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntfIntfV(*v, e)
 	case map[interface{}]string:
-		fastpathTV.EncMapIntfStringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfStringV(v, e)
 	case *map[interface{}]string:
-		fastpathTV.EncMapIntfStringV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntfStringV(*v, e)
 	case map[interface{}]uint:
-		fastpathTV.EncMapIntfUintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUintV(v, e)
 	case *map[interface{}]uint:
-		fastpathTV.EncMapIntfUintV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntfUintV(*v, e)
 	case map[interface{}]uint8:
-		fastpathTV.EncMapIntfUint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUint8V(v, e)
 	case *map[interface{}]uint8:
-		fastpathTV.EncMapIntfUint8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntfUint8V(*v, e)
 	case map[interface{}]uint16:
-		fastpathTV.EncMapIntfUint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUint16V(v, e)
 	case *map[interface{}]uint16:
-		fastpathTV.EncMapIntfUint16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntfUint16V(*v, e)
 	case map[interface{}]uint32:
-		fastpathTV.EncMapIntfUint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUint32V(v, e)
 	case *map[interface{}]uint32:
-		fastpathTV.EncMapIntfUint32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntfUint32V(*v, e)
 	case map[interface{}]uint64:
-		fastpathTV.EncMapIntfUint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUint64V(v, e)
 	case *map[interface{}]uint64:
-		fastpathTV.EncMapIntfUint64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntfUint64V(*v, e)
 	case map[interface{}]uintptr:
-		fastpathTV.EncMapIntfUintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfUintptrV(v, e)
 	case *map[interface{}]uintptr:
-		fastpathTV.EncMapIntfUintptrV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntfUintptrV(*v, e)
 	case map[interface{}]int:
-		fastpathTV.EncMapIntfIntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfIntV(v, e)
 	case *map[interface{}]int:
-		fastpathTV.EncMapIntfIntV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntfIntV(*v, e)
 	case map[interface{}]int8:
-		fastpathTV.EncMapIntfInt8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfInt8V(v, e)
 	case *map[interface{}]int8:
-		fastpathTV.EncMapIntfInt8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntfInt8V(*v, e)
 	case map[interface{}]int16:
-		fastpathTV.EncMapIntfInt16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfInt16V(v, e)
 	case *map[interface{}]int16:
-		fastpathTV.EncMapIntfInt16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntfInt16V(*v, e)
 	case map[interface{}]int32:
-		fastpathTV.EncMapIntfInt32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfInt32V(v, e)
 	case *map[interface{}]int32:
-		fastpathTV.EncMapIntfInt32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntfInt32V(*v, e)
 	case map[interface{}]int64:
-		fastpathTV.EncMapIntfInt64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfInt64V(v, e)
 	case *map[interface{}]int64:
-		fastpathTV.EncMapIntfInt64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntfInt64V(*v, e)
 	case map[interface{}]float32:
-		fastpathTV.EncMapIntfFloat32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfFloat32V(v, e)
 	case *map[interface{}]float32:
-		fastpathTV.EncMapIntfFloat32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntfFloat32V(*v, e)
 	case map[interface{}]float64:
-		fastpathTV.EncMapIntfFloat64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfFloat64V(v, e)
 	case *map[interface{}]float64:
-		fastpathTV.EncMapIntfFloat64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntfFloat64V(*v, e)
 	case map[interface{}]bool:
-		fastpathTV.EncMapIntfBoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntfBoolV(v, e)
 	case *map[interface{}]bool:
-		fastpathTV.EncMapIntfBoolV(*v, fastpathCheckNilTrue, e)
-
-	case []string:
-		fastpathTV.EncSliceStringV(v, fastpathCheckNilTrue, e)
-	case *[]string:
-		fastpathTV.EncSliceStringV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntfBoolV(*v, e)
 	case map[string]interface{}:
-		fastpathTV.EncMapStringIntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringIntfV(v, e)
 	case *map[string]interface{}:
-		fastpathTV.EncMapStringIntfV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapStringIntfV(*v, e)
 	case map[string]string:
-		fastpathTV.EncMapStringStringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringStringV(v, e)
 	case *map[string]string:
-		fastpathTV.EncMapStringStringV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapStringStringV(*v, e)
 	case map[string]uint:
-		fastpathTV.EncMapStringUintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUintV(v, e)
 	case *map[string]uint:
-		fastpathTV.EncMapStringUintV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapStringUintV(*v, e)
 	case map[string]uint8:
-		fastpathTV.EncMapStringUint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUint8V(v, e)
 	case *map[string]uint8:
-		fastpathTV.EncMapStringUint8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapStringUint8V(*v, e)
 	case map[string]uint16:
-		fastpathTV.EncMapStringUint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUint16V(v, e)
 	case *map[string]uint16:
-		fastpathTV.EncMapStringUint16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapStringUint16V(*v, e)
 	case map[string]uint32:
-		fastpathTV.EncMapStringUint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUint32V(v, e)
 	case *map[string]uint32:
-		fastpathTV.EncMapStringUint32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapStringUint32V(*v, e)
 	case map[string]uint64:
-		fastpathTV.EncMapStringUint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUint64V(v, e)
 	case *map[string]uint64:
-		fastpathTV.EncMapStringUint64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapStringUint64V(*v, e)
 	case map[string]uintptr:
-		fastpathTV.EncMapStringUintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringUintptrV(v, e)
 	case *map[string]uintptr:
-		fastpathTV.EncMapStringUintptrV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapStringUintptrV(*v, e)
 	case map[string]int:
-		fastpathTV.EncMapStringIntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringIntV(v, e)
 	case *map[string]int:
-		fastpathTV.EncMapStringIntV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapStringIntV(*v, e)
 	case map[string]int8:
-		fastpathTV.EncMapStringInt8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringInt8V(v, e)
 	case *map[string]int8:
-		fastpathTV.EncMapStringInt8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapStringInt8V(*v, e)
 	case map[string]int16:
-		fastpathTV.EncMapStringInt16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringInt16V(v, e)
 	case *map[string]int16:
-		fastpathTV.EncMapStringInt16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapStringInt16V(*v, e)
 	case map[string]int32:
-		fastpathTV.EncMapStringInt32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringInt32V(v, e)
 	case *map[string]int32:
-		fastpathTV.EncMapStringInt32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapStringInt32V(*v, e)
 	case map[string]int64:
-		fastpathTV.EncMapStringInt64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringInt64V(v, e)
 	case *map[string]int64:
-		fastpathTV.EncMapStringInt64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapStringInt64V(*v, e)
 	case map[string]float32:
-		fastpathTV.EncMapStringFloat32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringFloat32V(v, e)
 	case *map[string]float32:
-		fastpathTV.EncMapStringFloat32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapStringFloat32V(*v, e)
 	case map[string]float64:
-		fastpathTV.EncMapStringFloat64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringFloat64V(v, e)
 	case *map[string]float64:
-		fastpathTV.EncMapStringFloat64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapStringFloat64V(*v, e)
 	case map[string]bool:
-		fastpathTV.EncMapStringBoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapStringBoolV(v, e)
 	case *map[string]bool:
-		fastpathTV.EncMapStringBoolV(*v, fastpathCheckNilTrue, e)
-
-	case []float32:
-		fastpathTV.EncSliceFloat32V(v, fastpathCheckNilTrue, e)
-	case *[]float32:
-		fastpathTV.EncSliceFloat32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapStringBoolV(*v, e)
 	case map[float32]interface{}:
-		fastpathTV.EncMapFloat32IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32IntfV(v, e)
 	case *map[float32]interface{}:
-		fastpathTV.EncMapFloat32IntfV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat32IntfV(*v, e)
 	case map[float32]string:
-		fastpathTV.EncMapFloat32StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32StringV(v, e)
 	case *map[float32]string:
-		fastpathTV.EncMapFloat32StringV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat32StringV(*v, e)
 	case map[float32]uint:
-		fastpathTV.EncMapFloat32UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32UintV(v, e)
 	case *map[float32]uint:
-		fastpathTV.EncMapFloat32UintV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat32UintV(*v, e)
 	case map[float32]uint8:
-		fastpathTV.EncMapFloat32Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Uint8V(v, e)
 	case *map[float32]uint8:
-		fastpathTV.EncMapFloat32Uint8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat32Uint8V(*v, e)
 	case map[float32]uint16:
-		fastpathTV.EncMapFloat32Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Uint16V(v, e)
 	case *map[float32]uint16:
-		fastpathTV.EncMapFloat32Uint16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat32Uint16V(*v, e)
 	case map[float32]uint32:
-		fastpathTV.EncMapFloat32Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Uint32V(v, e)
 	case *map[float32]uint32:
-		fastpathTV.EncMapFloat32Uint32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat32Uint32V(*v, e)
 	case map[float32]uint64:
-		fastpathTV.EncMapFloat32Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Uint64V(v, e)
 	case *map[float32]uint64:
-		fastpathTV.EncMapFloat32Uint64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat32Uint64V(*v, e)
 	case map[float32]uintptr:
-		fastpathTV.EncMapFloat32UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32UintptrV(v, e)
 	case *map[float32]uintptr:
-		fastpathTV.EncMapFloat32UintptrV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat32UintptrV(*v, e)
 	case map[float32]int:
-		fastpathTV.EncMapFloat32IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32IntV(v, e)
 	case *map[float32]int:
-		fastpathTV.EncMapFloat32IntV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat32IntV(*v, e)
 	case map[float32]int8:
-		fastpathTV.EncMapFloat32Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Int8V(v, e)
 	case *map[float32]int8:
-		fastpathTV.EncMapFloat32Int8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat32Int8V(*v, e)
 	case map[float32]int16:
-		fastpathTV.EncMapFloat32Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Int16V(v, e)
 	case *map[float32]int16:
-		fastpathTV.EncMapFloat32Int16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat32Int16V(*v, e)
 	case map[float32]int32:
-		fastpathTV.EncMapFloat32Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Int32V(v, e)
 	case *map[float32]int32:
-		fastpathTV.EncMapFloat32Int32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat32Int32V(*v, e)
 	case map[float32]int64:
-		fastpathTV.EncMapFloat32Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Int64V(v, e)
 	case *map[float32]int64:
-		fastpathTV.EncMapFloat32Int64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat32Int64V(*v, e)
 	case map[float32]float32:
-		fastpathTV.EncMapFloat32Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Float32V(v, e)
 	case *map[float32]float32:
-		fastpathTV.EncMapFloat32Float32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat32Float32V(*v, e)
 	case map[float32]float64:
-		fastpathTV.EncMapFloat32Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32Float64V(v, e)
 	case *map[float32]float64:
-		fastpathTV.EncMapFloat32Float64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat32Float64V(*v, e)
 	case map[float32]bool:
-		fastpathTV.EncMapFloat32BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat32BoolV(v, e)
 	case *map[float32]bool:
-		fastpathTV.EncMapFloat32BoolV(*v, fastpathCheckNilTrue, e)
-
-	case []float64:
-		fastpathTV.EncSliceFloat64V(v, fastpathCheckNilTrue, e)
-	case *[]float64:
-		fastpathTV.EncSliceFloat64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat32BoolV(*v, e)
 	case map[float64]interface{}:
-		fastpathTV.EncMapFloat64IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64IntfV(v, e)
 	case *map[float64]interface{}:
-		fastpathTV.EncMapFloat64IntfV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat64IntfV(*v, e)
 	case map[float64]string:
-		fastpathTV.EncMapFloat64StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64StringV(v, e)
 	case *map[float64]string:
-		fastpathTV.EncMapFloat64StringV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat64StringV(*v, e)
 	case map[float64]uint:
-		fastpathTV.EncMapFloat64UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64UintV(v, e)
 	case *map[float64]uint:
-		fastpathTV.EncMapFloat64UintV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat64UintV(*v, e)
 	case map[float64]uint8:
-		fastpathTV.EncMapFloat64Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Uint8V(v, e)
 	case *map[float64]uint8:
-		fastpathTV.EncMapFloat64Uint8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat64Uint8V(*v, e)
 	case map[float64]uint16:
-		fastpathTV.EncMapFloat64Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Uint16V(v, e)
 	case *map[float64]uint16:
-		fastpathTV.EncMapFloat64Uint16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat64Uint16V(*v, e)
 	case map[float64]uint32:
-		fastpathTV.EncMapFloat64Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Uint32V(v, e)
 	case *map[float64]uint32:
-		fastpathTV.EncMapFloat64Uint32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat64Uint32V(*v, e)
 	case map[float64]uint64:
-		fastpathTV.EncMapFloat64Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Uint64V(v, e)
 	case *map[float64]uint64:
-		fastpathTV.EncMapFloat64Uint64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat64Uint64V(*v, e)
 	case map[float64]uintptr:
-		fastpathTV.EncMapFloat64UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64UintptrV(v, e)
 	case *map[float64]uintptr:
-		fastpathTV.EncMapFloat64UintptrV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat64UintptrV(*v, e)
 	case map[float64]int:
-		fastpathTV.EncMapFloat64IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64IntV(v, e)
 	case *map[float64]int:
-		fastpathTV.EncMapFloat64IntV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat64IntV(*v, e)
 	case map[float64]int8:
-		fastpathTV.EncMapFloat64Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Int8V(v, e)
 	case *map[float64]int8:
-		fastpathTV.EncMapFloat64Int8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat64Int8V(*v, e)
 	case map[float64]int16:
-		fastpathTV.EncMapFloat64Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Int16V(v, e)
 	case *map[float64]int16:
-		fastpathTV.EncMapFloat64Int16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat64Int16V(*v, e)
 	case map[float64]int32:
-		fastpathTV.EncMapFloat64Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Int32V(v, e)
 	case *map[float64]int32:
-		fastpathTV.EncMapFloat64Int32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat64Int32V(*v, e)
 	case map[float64]int64:
-		fastpathTV.EncMapFloat64Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Int64V(v, e)
 	case *map[float64]int64:
-		fastpathTV.EncMapFloat64Int64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat64Int64V(*v, e)
 	case map[float64]float32:
-		fastpathTV.EncMapFloat64Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Float32V(v, e)
 	case *map[float64]float32:
-		fastpathTV.EncMapFloat64Float32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat64Float32V(*v, e)
 	case map[float64]float64:
-		fastpathTV.EncMapFloat64Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64Float64V(v, e)
 	case *map[float64]float64:
-		fastpathTV.EncMapFloat64Float64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat64Float64V(*v, e)
 	case map[float64]bool:
-		fastpathTV.EncMapFloat64BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapFloat64BoolV(v, e)
 	case *map[float64]bool:
-		fastpathTV.EncMapFloat64BoolV(*v, fastpathCheckNilTrue, e)
-
-	case []uint:
-		fastpathTV.EncSliceUintV(v, fastpathCheckNilTrue, e)
-	case *[]uint:
-		fastpathTV.EncSliceUintV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapFloat64BoolV(*v, e)
 	case map[uint]interface{}:
-		fastpathTV.EncMapUintIntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintIntfV(v, e)
 	case *map[uint]interface{}:
-		fastpathTV.EncMapUintIntfV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintIntfV(*v, e)
 	case map[uint]string:
-		fastpathTV.EncMapUintStringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintStringV(v, e)
 	case *map[uint]string:
-		fastpathTV.EncMapUintStringV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintStringV(*v, e)
 	case map[uint]uint:
-		fastpathTV.EncMapUintUintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUintV(v, e)
 	case *map[uint]uint:
-		fastpathTV.EncMapUintUintV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintUintV(*v, e)
 	case map[uint]uint8:
-		fastpathTV.EncMapUintUint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUint8V(v, e)
 	case *map[uint]uint8:
-		fastpathTV.EncMapUintUint8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintUint8V(*v, e)
 	case map[uint]uint16:
-		fastpathTV.EncMapUintUint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUint16V(v, e)
 	case *map[uint]uint16:
-		fastpathTV.EncMapUintUint16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintUint16V(*v, e)
 	case map[uint]uint32:
-		fastpathTV.EncMapUintUint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUint32V(v, e)
 	case *map[uint]uint32:
-		fastpathTV.EncMapUintUint32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintUint32V(*v, e)
 	case map[uint]uint64:
-		fastpathTV.EncMapUintUint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUint64V(v, e)
 	case *map[uint]uint64:
-		fastpathTV.EncMapUintUint64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintUint64V(*v, e)
 	case map[uint]uintptr:
-		fastpathTV.EncMapUintUintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintUintptrV(v, e)
 	case *map[uint]uintptr:
-		fastpathTV.EncMapUintUintptrV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintUintptrV(*v, e)
 	case map[uint]int:
-		fastpathTV.EncMapUintIntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintIntV(v, e)
 	case *map[uint]int:
-		fastpathTV.EncMapUintIntV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintIntV(*v, e)
 	case map[uint]int8:
-		fastpathTV.EncMapUintInt8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintInt8V(v, e)
 	case *map[uint]int8:
-		fastpathTV.EncMapUintInt8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintInt8V(*v, e)
 	case map[uint]int16:
-		fastpathTV.EncMapUintInt16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintInt16V(v, e)
 	case *map[uint]int16:
-		fastpathTV.EncMapUintInt16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintInt16V(*v, e)
 	case map[uint]int32:
-		fastpathTV.EncMapUintInt32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintInt32V(v, e)
 	case *map[uint]int32:
-		fastpathTV.EncMapUintInt32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintInt32V(*v, e)
 	case map[uint]int64:
-		fastpathTV.EncMapUintInt64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintInt64V(v, e)
 	case *map[uint]int64:
-		fastpathTV.EncMapUintInt64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintInt64V(*v, e)
 	case map[uint]float32:
-		fastpathTV.EncMapUintFloat32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintFloat32V(v, e)
 	case *map[uint]float32:
-		fastpathTV.EncMapUintFloat32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintFloat32V(*v, e)
 	case map[uint]float64:
-		fastpathTV.EncMapUintFloat64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintFloat64V(v, e)
 	case *map[uint]float64:
-		fastpathTV.EncMapUintFloat64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintFloat64V(*v, e)
 	case map[uint]bool:
-		fastpathTV.EncMapUintBoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintBoolV(v, e)
 	case *map[uint]bool:
-		fastpathTV.EncMapUintBoolV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintBoolV(*v, e)
 	case map[uint8]interface{}:
-		fastpathTV.EncMapUint8IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8IntfV(v, e)
 	case *map[uint8]interface{}:
-		fastpathTV.EncMapUint8IntfV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint8IntfV(*v, e)
 	case map[uint8]string:
-		fastpathTV.EncMapUint8StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8StringV(v, e)
 	case *map[uint8]string:
-		fastpathTV.EncMapUint8StringV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint8StringV(*v, e)
 	case map[uint8]uint:
-		fastpathTV.EncMapUint8UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8UintV(v, e)
 	case *map[uint8]uint:
-		fastpathTV.EncMapUint8UintV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint8UintV(*v, e)
 	case map[uint8]uint8:
-		fastpathTV.EncMapUint8Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Uint8V(v, e)
 	case *map[uint8]uint8:
-		fastpathTV.EncMapUint8Uint8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint8Uint8V(*v, e)
 	case map[uint8]uint16:
-		fastpathTV.EncMapUint8Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Uint16V(v, e)
 	case *map[uint8]uint16:
-		fastpathTV.EncMapUint8Uint16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint8Uint16V(*v, e)
 	case map[uint8]uint32:
-		fastpathTV.EncMapUint8Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Uint32V(v, e)
 	case *map[uint8]uint32:
-		fastpathTV.EncMapUint8Uint32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint8Uint32V(*v, e)
 	case map[uint8]uint64:
-		fastpathTV.EncMapUint8Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Uint64V(v, e)
 	case *map[uint8]uint64:
-		fastpathTV.EncMapUint8Uint64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint8Uint64V(*v, e)
 	case map[uint8]uintptr:
-		fastpathTV.EncMapUint8UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8UintptrV(v, e)
 	case *map[uint8]uintptr:
-		fastpathTV.EncMapUint8UintptrV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint8UintptrV(*v, e)
 	case map[uint8]int:
-		fastpathTV.EncMapUint8IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8IntV(v, e)
 	case *map[uint8]int:
-		fastpathTV.EncMapUint8IntV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint8IntV(*v, e)
 	case map[uint8]int8:
-		fastpathTV.EncMapUint8Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Int8V(v, e)
 	case *map[uint8]int8:
-		fastpathTV.EncMapUint8Int8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint8Int8V(*v, e)
 	case map[uint8]int16:
-		fastpathTV.EncMapUint8Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Int16V(v, e)
 	case *map[uint8]int16:
-		fastpathTV.EncMapUint8Int16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint8Int16V(*v, e)
 	case map[uint8]int32:
-		fastpathTV.EncMapUint8Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Int32V(v, e)
 	case *map[uint8]int32:
-		fastpathTV.EncMapUint8Int32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint8Int32V(*v, e)
 	case map[uint8]int64:
-		fastpathTV.EncMapUint8Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Int64V(v, e)
 	case *map[uint8]int64:
-		fastpathTV.EncMapUint8Int64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint8Int64V(*v, e)
 	case map[uint8]float32:
-		fastpathTV.EncMapUint8Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Float32V(v, e)
 	case *map[uint8]float32:
-		fastpathTV.EncMapUint8Float32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint8Float32V(*v, e)
 	case map[uint8]float64:
-		fastpathTV.EncMapUint8Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8Float64V(v, e)
 	case *map[uint8]float64:
-		fastpathTV.EncMapUint8Float64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint8Float64V(*v, e)
 	case map[uint8]bool:
-		fastpathTV.EncMapUint8BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint8BoolV(v, e)
 	case *map[uint8]bool:
-		fastpathTV.EncMapUint8BoolV(*v, fastpathCheckNilTrue, e)
-
-	case []uint16:
-		fastpathTV.EncSliceUint16V(v, fastpathCheckNilTrue, e)
-	case *[]uint16:
-		fastpathTV.EncSliceUint16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint8BoolV(*v, e)
 	case map[uint16]interface{}:
-		fastpathTV.EncMapUint16IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16IntfV(v, e)
 	case *map[uint16]interface{}:
-		fastpathTV.EncMapUint16IntfV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint16IntfV(*v, e)
 	case map[uint16]string:
-		fastpathTV.EncMapUint16StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16StringV(v, e)
 	case *map[uint16]string:
-		fastpathTV.EncMapUint16StringV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint16StringV(*v, e)
 	case map[uint16]uint:
-		fastpathTV.EncMapUint16UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16UintV(v, e)
 	case *map[uint16]uint:
-		fastpathTV.EncMapUint16UintV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint16UintV(*v, e)
 	case map[uint16]uint8:
-		fastpathTV.EncMapUint16Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Uint8V(v, e)
 	case *map[uint16]uint8:
-		fastpathTV.EncMapUint16Uint8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint16Uint8V(*v, e)
 	case map[uint16]uint16:
-		fastpathTV.EncMapUint16Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Uint16V(v, e)
 	case *map[uint16]uint16:
-		fastpathTV.EncMapUint16Uint16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint16Uint16V(*v, e)
 	case map[uint16]uint32:
-		fastpathTV.EncMapUint16Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Uint32V(v, e)
 	case *map[uint16]uint32:
-		fastpathTV.EncMapUint16Uint32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint16Uint32V(*v, e)
 	case map[uint16]uint64:
-		fastpathTV.EncMapUint16Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Uint64V(v, e)
 	case *map[uint16]uint64:
-		fastpathTV.EncMapUint16Uint64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint16Uint64V(*v, e)
 	case map[uint16]uintptr:
-		fastpathTV.EncMapUint16UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16UintptrV(v, e)
 	case *map[uint16]uintptr:
-		fastpathTV.EncMapUint16UintptrV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint16UintptrV(*v, e)
 	case map[uint16]int:
-		fastpathTV.EncMapUint16IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16IntV(v, e)
 	case *map[uint16]int:
-		fastpathTV.EncMapUint16IntV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint16IntV(*v, e)
 	case map[uint16]int8:
-		fastpathTV.EncMapUint16Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Int8V(v, e)
 	case *map[uint16]int8:
-		fastpathTV.EncMapUint16Int8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint16Int8V(*v, e)
 	case map[uint16]int16:
-		fastpathTV.EncMapUint16Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Int16V(v, e)
 	case *map[uint16]int16:
-		fastpathTV.EncMapUint16Int16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint16Int16V(*v, e)
 	case map[uint16]int32:
-		fastpathTV.EncMapUint16Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Int32V(v, e)
 	case *map[uint16]int32:
-		fastpathTV.EncMapUint16Int32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint16Int32V(*v, e)
 	case map[uint16]int64:
-		fastpathTV.EncMapUint16Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Int64V(v, e)
 	case *map[uint16]int64:
-		fastpathTV.EncMapUint16Int64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint16Int64V(*v, e)
 	case map[uint16]float32:
-		fastpathTV.EncMapUint16Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Float32V(v, e)
 	case *map[uint16]float32:
-		fastpathTV.EncMapUint16Float32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint16Float32V(*v, e)
 	case map[uint16]float64:
-		fastpathTV.EncMapUint16Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16Float64V(v, e)
 	case *map[uint16]float64:
-		fastpathTV.EncMapUint16Float64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint16Float64V(*v, e)
 	case map[uint16]bool:
-		fastpathTV.EncMapUint16BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint16BoolV(v, e)
 	case *map[uint16]bool:
-		fastpathTV.EncMapUint16BoolV(*v, fastpathCheckNilTrue, e)
-
-	case []uint32:
-		fastpathTV.EncSliceUint32V(v, fastpathCheckNilTrue, e)
-	case *[]uint32:
-		fastpathTV.EncSliceUint32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint16BoolV(*v, e)
 	case map[uint32]interface{}:
-		fastpathTV.EncMapUint32IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32IntfV(v, e)
 	case *map[uint32]interface{}:
-		fastpathTV.EncMapUint32IntfV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint32IntfV(*v, e)
 	case map[uint32]string:
-		fastpathTV.EncMapUint32StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32StringV(v, e)
 	case *map[uint32]string:
-		fastpathTV.EncMapUint32StringV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint32StringV(*v, e)
 	case map[uint32]uint:
-		fastpathTV.EncMapUint32UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32UintV(v, e)
 	case *map[uint32]uint:
-		fastpathTV.EncMapUint32UintV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint32UintV(*v, e)
 	case map[uint32]uint8:
-		fastpathTV.EncMapUint32Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Uint8V(v, e)
 	case *map[uint32]uint8:
-		fastpathTV.EncMapUint32Uint8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint32Uint8V(*v, e)
 	case map[uint32]uint16:
-		fastpathTV.EncMapUint32Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Uint16V(v, e)
 	case *map[uint32]uint16:
-		fastpathTV.EncMapUint32Uint16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint32Uint16V(*v, e)
 	case map[uint32]uint32:
-		fastpathTV.EncMapUint32Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Uint32V(v, e)
 	case *map[uint32]uint32:
-		fastpathTV.EncMapUint32Uint32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint32Uint32V(*v, e)
 	case map[uint32]uint64:
-		fastpathTV.EncMapUint32Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Uint64V(v, e)
 	case *map[uint32]uint64:
-		fastpathTV.EncMapUint32Uint64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint32Uint64V(*v, e)
 	case map[uint32]uintptr:
-		fastpathTV.EncMapUint32UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32UintptrV(v, e)
 	case *map[uint32]uintptr:
-		fastpathTV.EncMapUint32UintptrV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint32UintptrV(*v, e)
 	case map[uint32]int:
-		fastpathTV.EncMapUint32IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32IntV(v, e)
 	case *map[uint32]int:
-		fastpathTV.EncMapUint32IntV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint32IntV(*v, e)
 	case map[uint32]int8:
-		fastpathTV.EncMapUint32Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Int8V(v, e)
 	case *map[uint32]int8:
-		fastpathTV.EncMapUint32Int8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint32Int8V(*v, e)
 	case map[uint32]int16:
-		fastpathTV.EncMapUint32Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Int16V(v, e)
 	case *map[uint32]int16:
-		fastpathTV.EncMapUint32Int16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint32Int16V(*v, e)
 	case map[uint32]int32:
-		fastpathTV.EncMapUint32Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Int32V(v, e)
 	case *map[uint32]int32:
-		fastpathTV.EncMapUint32Int32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint32Int32V(*v, e)
 	case map[uint32]int64:
-		fastpathTV.EncMapUint32Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Int64V(v, e)
 	case *map[uint32]int64:
-		fastpathTV.EncMapUint32Int64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint32Int64V(*v, e)
 	case map[uint32]float32:
-		fastpathTV.EncMapUint32Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Float32V(v, e)
 	case *map[uint32]float32:
-		fastpathTV.EncMapUint32Float32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint32Float32V(*v, e)
 	case map[uint32]float64:
-		fastpathTV.EncMapUint32Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32Float64V(v, e)
 	case *map[uint32]float64:
-		fastpathTV.EncMapUint32Float64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint32Float64V(*v, e)
 	case map[uint32]bool:
-		fastpathTV.EncMapUint32BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint32BoolV(v, e)
 	case *map[uint32]bool:
-		fastpathTV.EncMapUint32BoolV(*v, fastpathCheckNilTrue, e)
-
-	case []uint64:
-		fastpathTV.EncSliceUint64V(v, fastpathCheckNilTrue, e)
-	case *[]uint64:
-		fastpathTV.EncSliceUint64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint32BoolV(*v, e)
 	case map[uint64]interface{}:
-		fastpathTV.EncMapUint64IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64IntfV(v, e)
 	case *map[uint64]interface{}:
-		fastpathTV.EncMapUint64IntfV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint64IntfV(*v, e)
 	case map[uint64]string:
-		fastpathTV.EncMapUint64StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64StringV(v, e)
 	case *map[uint64]string:
-		fastpathTV.EncMapUint64StringV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint64StringV(*v, e)
 	case map[uint64]uint:
-		fastpathTV.EncMapUint64UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64UintV(v, e)
 	case *map[uint64]uint:
-		fastpathTV.EncMapUint64UintV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint64UintV(*v, e)
 	case map[uint64]uint8:
-		fastpathTV.EncMapUint64Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Uint8V(v, e)
 	case *map[uint64]uint8:
-		fastpathTV.EncMapUint64Uint8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint64Uint8V(*v, e)
 	case map[uint64]uint16:
-		fastpathTV.EncMapUint64Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Uint16V(v, e)
 	case *map[uint64]uint16:
-		fastpathTV.EncMapUint64Uint16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint64Uint16V(*v, e)
 	case map[uint64]uint32:
-		fastpathTV.EncMapUint64Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Uint32V(v, e)
 	case *map[uint64]uint32:
-		fastpathTV.EncMapUint64Uint32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint64Uint32V(*v, e)
 	case map[uint64]uint64:
-		fastpathTV.EncMapUint64Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Uint64V(v, e)
 	case *map[uint64]uint64:
-		fastpathTV.EncMapUint64Uint64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint64Uint64V(*v, e)
 	case map[uint64]uintptr:
-		fastpathTV.EncMapUint64UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64UintptrV(v, e)
 	case *map[uint64]uintptr:
-		fastpathTV.EncMapUint64UintptrV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint64UintptrV(*v, e)
 	case map[uint64]int:
-		fastpathTV.EncMapUint64IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64IntV(v, e)
 	case *map[uint64]int:
-		fastpathTV.EncMapUint64IntV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint64IntV(*v, e)
 	case map[uint64]int8:
-		fastpathTV.EncMapUint64Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Int8V(v, e)
 	case *map[uint64]int8:
-		fastpathTV.EncMapUint64Int8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint64Int8V(*v, e)
 	case map[uint64]int16:
-		fastpathTV.EncMapUint64Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Int16V(v, e)
 	case *map[uint64]int16:
-		fastpathTV.EncMapUint64Int16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint64Int16V(*v, e)
 	case map[uint64]int32:
-		fastpathTV.EncMapUint64Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Int32V(v, e)
 	case *map[uint64]int32:
-		fastpathTV.EncMapUint64Int32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint64Int32V(*v, e)
 	case map[uint64]int64:
-		fastpathTV.EncMapUint64Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Int64V(v, e)
 	case *map[uint64]int64:
-		fastpathTV.EncMapUint64Int64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint64Int64V(*v, e)
 	case map[uint64]float32:
-		fastpathTV.EncMapUint64Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Float32V(v, e)
 	case *map[uint64]float32:
-		fastpathTV.EncMapUint64Float32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint64Float32V(*v, e)
 	case map[uint64]float64:
-		fastpathTV.EncMapUint64Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64Float64V(v, e)
 	case *map[uint64]float64:
-		fastpathTV.EncMapUint64Float64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint64Float64V(*v, e)
 	case map[uint64]bool:
-		fastpathTV.EncMapUint64BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUint64BoolV(v, e)
 	case *map[uint64]bool:
-		fastpathTV.EncMapUint64BoolV(*v, fastpathCheckNilTrue, e)
-
-	case []uintptr:
-		fastpathTV.EncSliceUintptrV(v, fastpathCheckNilTrue, e)
-	case *[]uintptr:
-		fastpathTV.EncSliceUintptrV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUint64BoolV(*v, e)
 	case map[uintptr]interface{}:
-		fastpathTV.EncMapUintptrIntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrIntfV(v, e)
 	case *map[uintptr]interface{}:
-		fastpathTV.EncMapUintptrIntfV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintptrIntfV(*v, e)
 	case map[uintptr]string:
-		fastpathTV.EncMapUintptrStringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrStringV(v, e)
 	case *map[uintptr]string:
-		fastpathTV.EncMapUintptrStringV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintptrStringV(*v, e)
 	case map[uintptr]uint:
-		fastpathTV.EncMapUintptrUintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUintV(v, e)
 	case *map[uintptr]uint:
-		fastpathTV.EncMapUintptrUintV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintptrUintV(*v, e)
 	case map[uintptr]uint8:
-		fastpathTV.EncMapUintptrUint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUint8V(v, e)
 	case *map[uintptr]uint8:
-		fastpathTV.EncMapUintptrUint8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintptrUint8V(*v, e)
 	case map[uintptr]uint16:
-		fastpathTV.EncMapUintptrUint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUint16V(v, e)
 	case *map[uintptr]uint16:
-		fastpathTV.EncMapUintptrUint16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintptrUint16V(*v, e)
 	case map[uintptr]uint32:
-		fastpathTV.EncMapUintptrUint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUint32V(v, e)
 	case *map[uintptr]uint32:
-		fastpathTV.EncMapUintptrUint32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintptrUint32V(*v, e)
 	case map[uintptr]uint64:
-		fastpathTV.EncMapUintptrUint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUint64V(v, e)
 	case *map[uintptr]uint64:
-		fastpathTV.EncMapUintptrUint64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintptrUint64V(*v, e)
 	case map[uintptr]uintptr:
-		fastpathTV.EncMapUintptrUintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrUintptrV(v, e)
 	case *map[uintptr]uintptr:
-		fastpathTV.EncMapUintptrUintptrV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintptrUintptrV(*v, e)
 	case map[uintptr]int:
-		fastpathTV.EncMapUintptrIntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrIntV(v, e)
 	case *map[uintptr]int:
-		fastpathTV.EncMapUintptrIntV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintptrIntV(*v, e)
 	case map[uintptr]int8:
-		fastpathTV.EncMapUintptrInt8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrInt8V(v, e)
 	case *map[uintptr]int8:
-		fastpathTV.EncMapUintptrInt8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintptrInt8V(*v, e)
 	case map[uintptr]int16:
-		fastpathTV.EncMapUintptrInt16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrInt16V(v, e)
 	case *map[uintptr]int16:
-		fastpathTV.EncMapUintptrInt16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintptrInt16V(*v, e)
 	case map[uintptr]int32:
-		fastpathTV.EncMapUintptrInt32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrInt32V(v, e)
 	case *map[uintptr]int32:
-		fastpathTV.EncMapUintptrInt32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintptrInt32V(*v, e)
 	case map[uintptr]int64:
-		fastpathTV.EncMapUintptrInt64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrInt64V(v, e)
 	case *map[uintptr]int64:
-		fastpathTV.EncMapUintptrInt64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintptrInt64V(*v, e)
 	case map[uintptr]float32:
-		fastpathTV.EncMapUintptrFloat32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrFloat32V(v, e)
 	case *map[uintptr]float32:
-		fastpathTV.EncMapUintptrFloat32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintptrFloat32V(*v, e)
 	case map[uintptr]float64:
-		fastpathTV.EncMapUintptrFloat64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrFloat64V(v, e)
 	case *map[uintptr]float64:
-		fastpathTV.EncMapUintptrFloat64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintptrFloat64V(*v, e)
 	case map[uintptr]bool:
-		fastpathTV.EncMapUintptrBoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapUintptrBoolV(v, e)
 	case *map[uintptr]bool:
-		fastpathTV.EncMapUintptrBoolV(*v, fastpathCheckNilTrue, e)
-
-	case []int:
-		fastpathTV.EncSliceIntV(v, fastpathCheckNilTrue, e)
-	case *[]int:
-		fastpathTV.EncSliceIntV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapUintptrBoolV(*v, e)
 	case map[int]interface{}:
-		fastpathTV.EncMapIntIntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntIntfV(v, e)
 	case *map[int]interface{}:
-		fastpathTV.EncMapIntIntfV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntIntfV(*v, e)
 	case map[int]string:
-		fastpathTV.EncMapIntStringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntStringV(v, e)
 	case *map[int]string:
-		fastpathTV.EncMapIntStringV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntStringV(*v, e)
 	case map[int]uint:
-		fastpathTV.EncMapIntUintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUintV(v, e)
 	case *map[int]uint:
-		fastpathTV.EncMapIntUintV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntUintV(*v, e)
 	case map[int]uint8:
-		fastpathTV.EncMapIntUint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUint8V(v, e)
 	case *map[int]uint8:
-		fastpathTV.EncMapIntUint8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntUint8V(*v, e)
 	case map[int]uint16:
-		fastpathTV.EncMapIntUint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUint16V(v, e)
 	case *map[int]uint16:
-		fastpathTV.EncMapIntUint16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntUint16V(*v, e)
 	case map[int]uint32:
-		fastpathTV.EncMapIntUint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUint32V(v, e)
 	case *map[int]uint32:
-		fastpathTV.EncMapIntUint32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntUint32V(*v, e)
 	case map[int]uint64:
-		fastpathTV.EncMapIntUint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUint64V(v, e)
 	case *map[int]uint64:
-		fastpathTV.EncMapIntUint64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntUint64V(*v, e)
 	case map[int]uintptr:
-		fastpathTV.EncMapIntUintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntUintptrV(v, e)
 	case *map[int]uintptr:
-		fastpathTV.EncMapIntUintptrV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntUintptrV(*v, e)
 	case map[int]int:
-		fastpathTV.EncMapIntIntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntIntV(v, e)
 	case *map[int]int:
-		fastpathTV.EncMapIntIntV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntIntV(*v, e)
 	case map[int]int8:
-		fastpathTV.EncMapIntInt8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntInt8V(v, e)
 	case *map[int]int8:
-		fastpathTV.EncMapIntInt8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntInt8V(*v, e)
 	case map[int]int16:
-		fastpathTV.EncMapIntInt16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntInt16V(v, e)
 	case *map[int]int16:
-		fastpathTV.EncMapIntInt16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntInt16V(*v, e)
 	case map[int]int32:
-		fastpathTV.EncMapIntInt32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntInt32V(v, e)
 	case *map[int]int32:
-		fastpathTV.EncMapIntInt32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntInt32V(*v, e)
 	case map[int]int64:
-		fastpathTV.EncMapIntInt64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntInt64V(v, e)
 	case *map[int]int64:
-		fastpathTV.EncMapIntInt64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntInt64V(*v, e)
 	case map[int]float32:
-		fastpathTV.EncMapIntFloat32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntFloat32V(v, e)
 	case *map[int]float32:
-		fastpathTV.EncMapIntFloat32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntFloat32V(*v, e)
 	case map[int]float64:
-		fastpathTV.EncMapIntFloat64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntFloat64V(v, e)
 	case *map[int]float64:
-		fastpathTV.EncMapIntFloat64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntFloat64V(*v, e)
 	case map[int]bool:
-		fastpathTV.EncMapIntBoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapIntBoolV(v, e)
 	case *map[int]bool:
-		fastpathTV.EncMapIntBoolV(*v, fastpathCheckNilTrue, e)
-
-	case []int8:
-		fastpathTV.EncSliceInt8V(v, fastpathCheckNilTrue, e)
-	case *[]int8:
-		fastpathTV.EncSliceInt8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapIntBoolV(*v, e)
 	case map[int8]interface{}:
-		fastpathTV.EncMapInt8IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8IntfV(v, e)
 	case *map[int8]interface{}:
-		fastpathTV.EncMapInt8IntfV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt8IntfV(*v, e)
 	case map[int8]string:
-		fastpathTV.EncMapInt8StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8StringV(v, e)
 	case *map[int8]string:
-		fastpathTV.EncMapInt8StringV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt8StringV(*v, e)
 	case map[int8]uint:
-		fastpathTV.EncMapInt8UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8UintV(v, e)
 	case *map[int8]uint:
-		fastpathTV.EncMapInt8UintV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt8UintV(*v, e)
 	case map[int8]uint8:
-		fastpathTV.EncMapInt8Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Uint8V(v, e)
 	case *map[int8]uint8:
-		fastpathTV.EncMapInt8Uint8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt8Uint8V(*v, e)
 	case map[int8]uint16:
-		fastpathTV.EncMapInt8Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Uint16V(v, e)
 	case *map[int8]uint16:
-		fastpathTV.EncMapInt8Uint16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt8Uint16V(*v, e)
 	case map[int8]uint32:
-		fastpathTV.EncMapInt8Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Uint32V(v, e)
 	case *map[int8]uint32:
-		fastpathTV.EncMapInt8Uint32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt8Uint32V(*v, e)
 	case map[int8]uint64:
-		fastpathTV.EncMapInt8Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Uint64V(v, e)
 	case *map[int8]uint64:
-		fastpathTV.EncMapInt8Uint64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt8Uint64V(*v, e)
 	case map[int8]uintptr:
-		fastpathTV.EncMapInt8UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8UintptrV(v, e)
 	case *map[int8]uintptr:
-		fastpathTV.EncMapInt8UintptrV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt8UintptrV(*v, e)
 	case map[int8]int:
-		fastpathTV.EncMapInt8IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8IntV(v, e)
 	case *map[int8]int:
-		fastpathTV.EncMapInt8IntV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt8IntV(*v, e)
 	case map[int8]int8:
-		fastpathTV.EncMapInt8Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Int8V(v, e)
 	case *map[int8]int8:
-		fastpathTV.EncMapInt8Int8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt8Int8V(*v, e)
 	case map[int8]int16:
-		fastpathTV.EncMapInt8Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Int16V(v, e)
 	case *map[int8]int16:
-		fastpathTV.EncMapInt8Int16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt8Int16V(*v, e)
 	case map[int8]int32:
-		fastpathTV.EncMapInt8Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Int32V(v, e)
 	case *map[int8]int32:
-		fastpathTV.EncMapInt8Int32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt8Int32V(*v, e)
 	case map[int8]int64:
-		fastpathTV.EncMapInt8Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Int64V(v, e)
 	case *map[int8]int64:
-		fastpathTV.EncMapInt8Int64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt8Int64V(*v, e)
 	case map[int8]float32:
-		fastpathTV.EncMapInt8Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Float32V(v, e)
 	case *map[int8]float32:
-		fastpathTV.EncMapInt8Float32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt8Float32V(*v, e)
 	case map[int8]float64:
-		fastpathTV.EncMapInt8Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8Float64V(v, e)
 	case *map[int8]float64:
-		fastpathTV.EncMapInt8Float64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt8Float64V(*v, e)
 	case map[int8]bool:
-		fastpathTV.EncMapInt8BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt8BoolV(v, e)
 	case *map[int8]bool:
-		fastpathTV.EncMapInt8BoolV(*v, fastpathCheckNilTrue, e)
-
-	case []int16:
-		fastpathTV.EncSliceInt16V(v, fastpathCheckNilTrue, e)
-	case *[]int16:
-		fastpathTV.EncSliceInt16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt8BoolV(*v, e)
 	case map[int16]interface{}:
-		fastpathTV.EncMapInt16IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16IntfV(v, e)
 	case *map[int16]interface{}:
-		fastpathTV.EncMapInt16IntfV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt16IntfV(*v, e)
 	case map[int16]string:
-		fastpathTV.EncMapInt16StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16StringV(v, e)
 	case *map[int16]string:
-		fastpathTV.EncMapInt16StringV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt16StringV(*v, e)
 	case map[int16]uint:
-		fastpathTV.EncMapInt16UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16UintV(v, e)
 	case *map[int16]uint:
-		fastpathTV.EncMapInt16UintV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt16UintV(*v, e)
 	case map[int16]uint8:
-		fastpathTV.EncMapInt16Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Uint8V(v, e)
 	case *map[int16]uint8:
-		fastpathTV.EncMapInt16Uint8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt16Uint8V(*v, e)
 	case map[int16]uint16:
-		fastpathTV.EncMapInt16Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Uint16V(v, e)
 	case *map[int16]uint16:
-		fastpathTV.EncMapInt16Uint16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt16Uint16V(*v, e)
 	case map[int16]uint32:
-		fastpathTV.EncMapInt16Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Uint32V(v, e)
 	case *map[int16]uint32:
-		fastpathTV.EncMapInt16Uint32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt16Uint32V(*v, e)
 	case map[int16]uint64:
-		fastpathTV.EncMapInt16Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Uint64V(v, e)
 	case *map[int16]uint64:
-		fastpathTV.EncMapInt16Uint64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt16Uint64V(*v, e)
 	case map[int16]uintptr:
-		fastpathTV.EncMapInt16UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16UintptrV(v, e)
 	case *map[int16]uintptr:
-		fastpathTV.EncMapInt16UintptrV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt16UintptrV(*v, e)
 	case map[int16]int:
-		fastpathTV.EncMapInt16IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16IntV(v, e)
 	case *map[int16]int:
-		fastpathTV.EncMapInt16IntV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt16IntV(*v, e)
 	case map[int16]int8:
-		fastpathTV.EncMapInt16Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Int8V(v, e)
 	case *map[int16]int8:
-		fastpathTV.EncMapInt16Int8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt16Int8V(*v, e)
 	case map[int16]int16:
-		fastpathTV.EncMapInt16Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Int16V(v, e)
 	case *map[int16]int16:
-		fastpathTV.EncMapInt16Int16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt16Int16V(*v, e)
 	case map[int16]int32:
-		fastpathTV.EncMapInt16Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Int32V(v, e)
 	case *map[int16]int32:
-		fastpathTV.EncMapInt16Int32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt16Int32V(*v, e)
 	case map[int16]int64:
-		fastpathTV.EncMapInt16Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Int64V(v, e)
 	case *map[int16]int64:
-		fastpathTV.EncMapInt16Int64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt16Int64V(*v, e)
 	case map[int16]float32:
-		fastpathTV.EncMapInt16Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Float32V(v, e)
 	case *map[int16]float32:
-		fastpathTV.EncMapInt16Float32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt16Float32V(*v, e)
 	case map[int16]float64:
-		fastpathTV.EncMapInt16Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16Float64V(v, e)
 	case *map[int16]float64:
-		fastpathTV.EncMapInt16Float64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt16Float64V(*v, e)
 	case map[int16]bool:
-		fastpathTV.EncMapInt16BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt16BoolV(v, e)
 	case *map[int16]bool:
-		fastpathTV.EncMapInt16BoolV(*v, fastpathCheckNilTrue, e)
-
-	case []int32:
-		fastpathTV.EncSliceInt32V(v, fastpathCheckNilTrue, e)
-	case *[]int32:
-		fastpathTV.EncSliceInt32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt16BoolV(*v, e)
 	case map[int32]interface{}:
-		fastpathTV.EncMapInt32IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32IntfV(v, e)
 	case *map[int32]interface{}:
-		fastpathTV.EncMapInt32IntfV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt32IntfV(*v, e)
 	case map[int32]string:
-		fastpathTV.EncMapInt32StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32StringV(v, e)
 	case *map[int32]string:
-		fastpathTV.EncMapInt32StringV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt32StringV(*v, e)
 	case map[int32]uint:
-		fastpathTV.EncMapInt32UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32UintV(v, e)
 	case *map[int32]uint:
-		fastpathTV.EncMapInt32UintV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt32UintV(*v, e)
 	case map[int32]uint8:
-		fastpathTV.EncMapInt32Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Uint8V(v, e)
 	case *map[int32]uint8:
-		fastpathTV.EncMapInt32Uint8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt32Uint8V(*v, e)
 	case map[int32]uint16:
-		fastpathTV.EncMapInt32Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Uint16V(v, e)
 	case *map[int32]uint16:
-		fastpathTV.EncMapInt32Uint16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt32Uint16V(*v, e)
 	case map[int32]uint32:
-		fastpathTV.EncMapInt32Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Uint32V(v, e)
 	case *map[int32]uint32:
-		fastpathTV.EncMapInt32Uint32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt32Uint32V(*v, e)
 	case map[int32]uint64:
-		fastpathTV.EncMapInt32Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Uint64V(v, e)
 	case *map[int32]uint64:
-		fastpathTV.EncMapInt32Uint64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt32Uint64V(*v, e)
 	case map[int32]uintptr:
-		fastpathTV.EncMapInt32UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32UintptrV(v, e)
 	case *map[int32]uintptr:
-		fastpathTV.EncMapInt32UintptrV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt32UintptrV(*v, e)
 	case map[int32]int:
-		fastpathTV.EncMapInt32IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32IntV(v, e)
 	case *map[int32]int:
-		fastpathTV.EncMapInt32IntV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt32IntV(*v, e)
 	case map[int32]int8:
-		fastpathTV.EncMapInt32Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Int8V(v, e)
 	case *map[int32]int8:
-		fastpathTV.EncMapInt32Int8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt32Int8V(*v, e)
 	case map[int32]int16:
-		fastpathTV.EncMapInt32Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Int16V(v, e)
 	case *map[int32]int16:
-		fastpathTV.EncMapInt32Int16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt32Int16V(*v, e)
 	case map[int32]int32:
-		fastpathTV.EncMapInt32Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Int32V(v, e)
 	case *map[int32]int32:
-		fastpathTV.EncMapInt32Int32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt32Int32V(*v, e)
 	case map[int32]int64:
-		fastpathTV.EncMapInt32Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Int64V(v, e)
 	case *map[int32]int64:
-		fastpathTV.EncMapInt32Int64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt32Int64V(*v, e)
 	case map[int32]float32:
-		fastpathTV.EncMapInt32Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Float32V(v, e)
 	case *map[int32]float32:
-		fastpathTV.EncMapInt32Float32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt32Float32V(*v, e)
 	case map[int32]float64:
-		fastpathTV.EncMapInt32Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32Float64V(v, e)
 	case *map[int32]float64:
-		fastpathTV.EncMapInt32Float64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt32Float64V(*v, e)
 	case map[int32]bool:
-		fastpathTV.EncMapInt32BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt32BoolV(v, e)
 	case *map[int32]bool:
-		fastpathTV.EncMapInt32BoolV(*v, fastpathCheckNilTrue, e)
-
-	case []int64:
-		fastpathTV.EncSliceInt64V(v, fastpathCheckNilTrue, e)
-	case *[]int64:
-		fastpathTV.EncSliceInt64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt32BoolV(*v, e)
 	case map[int64]interface{}:
-		fastpathTV.EncMapInt64IntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64IntfV(v, e)
 	case *map[int64]interface{}:
-		fastpathTV.EncMapInt64IntfV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt64IntfV(*v, e)
 	case map[int64]string:
-		fastpathTV.EncMapInt64StringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64StringV(v, e)
 	case *map[int64]string:
-		fastpathTV.EncMapInt64StringV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt64StringV(*v, e)
 	case map[int64]uint:
-		fastpathTV.EncMapInt64UintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64UintV(v, e)
 	case *map[int64]uint:
-		fastpathTV.EncMapInt64UintV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt64UintV(*v, e)
 	case map[int64]uint8:
-		fastpathTV.EncMapInt64Uint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Uint8V(v, e)
 	case *map[int64]uint8:
-		fastpathTV.EncMapInt64Uint8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt64Uint8V(*v, e)
 	case map[int64]uint16:
-		fastpathTV.EncMapInt64Uint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Uint16V(v, e)
 	case *map[int64]uint16:
-		fastpathTV.EncMapInt64Uint16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt64Uint16V(*v, e)
 	case map[int64]uint32:
-		fastpathTV.EncMapInt64Uint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Uint32V(v, e)
 	case *map[int64]uint32:
-		fastpathTV.EncMapInt64Uint32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt64Uint32V(*v, e)
 	case map[int64]uint64:
-		fastpathTV.EncMapInt64Uint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Uint64V(v, e)
 	case *map[int64]uint64:
-		fastpathTV.EncMapInt64Uint64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt64Uint64V(*v, e)
 	case map[int64]uintptr:
-		fastpathTV.EncMapInt64UintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64UintptrV(v, e)
 	case *map[int64]uintptr:
-		fastpathTV.EncMapInt64UintptrV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt64UintptrV(*v, e)
 	case map[int64]int:
-		fastpathTV.EncMapInt64IntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64IntV(v, e)
 	case *map[int64]int:
-		fastpathTV.EncMapInt64IntV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt64IntV(*v, e)
 	case map[int64]int8:
-		fastpathTV.EncMapInt64Int8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Int8V(v, e)
 	case *map[int64]int8:
-		fastpathTV.EncMapInt64Int8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt64Int8V(*v, e)
 	case map[int64]int16:
-		fastpathTV.EncMapInt64Int16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Int16V(v, e)
 	case *map[int64]int16:
-		fastpathTV.EncMapInt64Int16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt64Int16V(*v, e)
 	case map[int64]int32:
-		fastpathTV.EncMapInt64Int32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Int32V(v, e)
 	case *map[int64]int32:
-		fastpathTV.EncMapInt64Int32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt64Int32V(*v, e)
 	case map[int64]int64:
-		fastpathTV.EncMapInt64Int64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Int64V(v, e)
 	case *map[int64]int64:
-		fastpathTV.EncMapInt64Int64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt64Int64V(*v, e)
 	case map[int64]float32:
-		fastpathTV.EncMapInt64Float32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Float32V(v, e)
 	case *map[int64]float32:
-		fastpathTV.EncMapInt64Float32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt64Float32V(*v, e)
 	case map[int64]float64:
-		fastpathTV.EncMapInt64Float64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64Float64V(v, e)
 	case *map[int64]float64:
-		fastpathTV.EncMapInt64Float64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt64Float64V(*v, e)
 	case map[int64]bool:
-		fastpathTV.EncMapInt64BoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapInt64BoolV(v, e)
 	case *map[int64]bool:
-		fastpathTV.EncMapInt64BoolV(*v, fastpathCheckNilTrue, e)
-
-	case []bool:
-		fastpathTV.EncSliceBoolV(v, fastpathCheckNilTrue, e)
-	case *[]bool:
-		fastpathTV.EncSliceBoolV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapInt64BoolV(*v, e)
 	case map[bool]interface{}:
-		fastpathTV.EncMapBoolIntfV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolIntfV(v, e)
 	case *map[bool]interface{}:
-		fastpathTV.EncMapBoolIntfV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapBoolIntfV(*v, e)
 	case map[bool]string:
-		fastpathTV.EncMapBoolStringV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolStringV(v, e)
 	case *map[bool]string:
-		fastpathTV.EncMapBoolStringV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapBoolStringV(*v, e)
 	case map[bool]uint:
-		fastpathTV.EncMapBoolUintV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUintV(v, e)
 	case *map[bool]uint:
-		fastpathTV.EncMapBoolUintV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapBoolUintV(*v, e)
 	case map[bool]uint8:
-		fastpathTV.EncMapBoolUint8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUint8V(v, e)
 	case *map[bool]uint8:
-		fastpathTV.EncMapBoolUint8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapBoolUint8V(*v, e)
 	case map[bool]uint16:
-		fastpathTV.EncMapBoolUint16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUint16V(v, e)
 	case *map[bool]uint16:
-		fastpathTV.EncMapBoolUint16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapBoolUint16V(*v, e)
 	case map[bool]uint32:
-		fastpathTV.EncMapBoolUint32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUint32V(v, e)
 	case *map[bool]uint32:
-		fastpathTV.EncMapBoolUint32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapBoolUint32V(*v, e)
 	case map[bool]uint64:
-		fastpathTV.EncMapBoolUint64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUint64V(v, e)
 	case *map[bool]uint64:
-		fastpathTV.EncMapBoolUint64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapBoolUint64V(*v, e)
 	case map[bool]uintptr:
-		fastpathTV.EncMapBoolUintptrV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolUintptrV(v, e)
 	case *map[bool]uintptr:
-		fastpathTV.EncMapBoolUintptrV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapBoolUintptrV(*v, e)
 	case map[bool]int:
-		fastpathTV.EncMapBoolIntV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolIntV(v, e)
 	case *map[bool]int:
-		fastpathTV.EncMapBoolIntV(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapBoolIntV(*v, e)
 	case map[bool]int8:
-		fastpathTV.EncMapBoolInt8V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolInt8V(v, e)
 	case *map[bool]int8:
-		fastpathTV.EncMapBoolInt8V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapBoolInt8V(*v, e)
 	case map[bool]int16:
-		fastpathTV.EncMapBoolInt16V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolInt16V(v, e)
 	case *map[bool]int16:
-		fastpathTV.EncMapBoolInt16V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapBoolInt16V(*v, e)
 	case map[bool]int32:
-		fastpathTV.EncMapBoolInt32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolInt32V(v, e)
 	case *map[bool]int32:
-		fastpathTV.EncMapBoolInt32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapBoolInt32V(*v, e)
 	case map[bool]int64:
-		fastpathTV.EncMapBoolInt64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolInt64V(v, e)
 	case *map[bool]int64:
-		fastpathTV.EncMapBoolInt64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapBoolInt64V(*v, e)
 	case map[bool]float32:
-		fastpathTV.EncMapBoolFloat32V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolFloat32V(v, e)
 	case *map[bool]float32:
-		fastpathTV.EncMapBoolFloat32V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapBoolFloat32V(*v, e)
 	case map[bool]float64:
-		fastpathTV.EncMapBoolFloat64V(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolFloat64V(v, e)
 	case *map[bool]float64:
-		fastpathTV.EncMapBoolFloat64V(*v, fastpathCheckNilTrue, e)
-
+		fastpathTV.EncMapBoolFloat64V(*v, e)
 	case map[bool]bool:
-		fastpathTV.EncMapBoolBoolV(v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolBoolV(v, e)
 	case *map[bool]bool:
-		fastpathTV.EncMapBoolBoolV(*v, fastpathCheckNilTrue, e)
-
-	default:
-		_ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
-		return false
-	}
-	return true
-}
-
-func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool {
-	switch v := iv.(type) {
-
-	case []interface{}:
-		fastpathTV.EncSliceIntfV(v, fastpathCheckNilTrue, e)
-	case *[]interface{}:
-		fastpathTV.EncSliceIntfV(*v, fastpathCheckNilTrue, e)
-
-	case []string:
-		fastpathTV.EncSliceStringV(v, fastpathCheckNilTrue, e)
-	case *[]string:
-		fastpathTV.EncSliceStringV(*v, fastpathCheckNilTrue, e)
-
-	case []float32:
-		fastpathTV.EncSliceFloat32V(v, fastpathCheckNilTrue, e)
-	case *[]float32:
-		fastpathTV.EncSliceFloat32V(*v, fastpathCheckNilTrue, e)
-
-	case []float64:
-		fastpathTV.EncSliceFloat64V(v, fastpathCheckNilTrue, e)
-	case *[]float64:
-		fastpathTV.EncSliceFloat64V(*v, fastpathCheckNilTrue, e)
-
-	case []uint:
-		fastpathTV.EncSliceUintV(v, fastpathCheckNilTrue, e)
-	case *[]uint:
-		fastpathTV.EncSliceUintV(*v, fastpathCheckNilTrue, e)
-
-	case []uint16:
-		fastpathTV.EncSliceUint16V(v, fastpathCheckNilTrue, e)
-	case *[]uint16:
-		fastpathTV.EncSliceUint16V(*v, fastpathCheckNilTrue, e)
-
-	case []uint32:
-		fastpathTV.EncSliceUint32V(v, fastpathCheckNilTrue, e)
-	case *[]uint32:
-		fastpathTV.EncSliceUint32V(*v, fastpathCheckNilTrue, e)
-
-	case []uint64:
-		fastpathTV.EncSliceUint64V(v, fastpathCheckNilTrue, e)
-	case *[]uint64:
-		fastpathTV.EncSliceUint64V(*v, fastpathCheckNilTrue, e)
-
-	case []uintptr:
-		fastpathTV.EncSliceUintptrV(v, fastpathCheckNilTrue, e)
-	case *[]uintptr:
-		fastpathTV.EncSliceUintptrV(*v, fastpathCheckNilTrue, e)
-
-	case []int:
-		fastpathTV.EncSliceIntV(v, fastpathCheckNilTrue, e)
-	case *[]int:
-		fastpathTV.EncSliceIntV(*v, fastpathCheckNilTrue, e)
-
-	case []int8:
-		fastpathTV.EncSliceInt8V(v, fastpathCheckNilTrue, e)
-	case *[]int8:
-		fastpathTV.EncSliceInt8V(*v, fastpathCheckNilTrue, e)
-
-	case []int16:
-		fastpathTV.EncSliceInt16V(v, fastpathCheckNilTrue, e)
-	case *[]int16:
-		fastpathTV.EncSliceInt16V(*v, fastpathCheckNilTrue, e)
-
-	case []int32:
-		fastpathTV.EncSliceInt32V(v, fastpathCheckNilTrue, e)
-	case *[]int32:
-		fastpathTV.EncSliceInt32V(*v, fastpathCheckNilTrue, e)
-
-	case []int64:
-		fastpathTV.EncSliceInt64V(v, fastpathCheckNilTrue, e)
-	case *[]int64:
-		fastpathTV.EncSliceInt64V(*v, fastpathCheckNilTrue, e)
-
-	case []bool:
-		fastpathTV.EncSliceBoolV(v, fastpathCheckNilTrue, e)
-	case *[]bool:
-		fastpathTV.EncSliceBoolV(*v, fastpathCheckNilTrue, e)
-
-	default:
-		_ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
-		return false
-	}
-	return true
-}
-
-func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool {
-	switch v := iv.(type) {
-
-	case map[interface{}]interface{}:
-		fastpathTV.EncMapIntfIntfV(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]interface{}:
-		fastpathTV.EncMapIntfIntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]string:
-		fastpathTV.EncMapIntfStringV(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]string:
-		fastpathTV.EncMapIntfStringV(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]uint:
-		fastpathTV.EncMapIntfUintV(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]uint:
-		fastpathTV.EncMapIntfUintV(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]uint8:
-		fastpathTV.EncMapIntfUint8V(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]uint8:
-		fastpathTV.EncMapIntfUint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]uint16:
-		fastpathTV.EncMapIntfUint16V(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]uint16:
-		fastpathTV.EncMapIntfUint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]uint32:
-		fastpathTV.EncMapIntfUint32V(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]uint32:
-		fastpathTV.EncMapIntfUint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]uint64:
-		fastpathTV.EncMapIntfUint64V(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]uint64:
-		fastpathTV.EncMapIntfUint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]uintptr:
-		fastpathTV.EncMapIntfUintptrV(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]uintptr:
-		fastpathTV.EncMapIntfUintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]int:
-		fastpathTV.EncMapIntfIntV(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]int:
-		fastpathTV.EncMapIntfIntV(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]int8:
-		fastpathTV.EncMapIntfInt8V(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]int8:
-		fastpathTV.EncMapIntfInt8V(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]int16:
-		fastpathTV.EncMapIntfInt16V(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]int16:
-		fastpathTV.EncMapIntfInt16V(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]int32:
-		fastpathTV.EncMapIntfInt32V(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]int32:
-		fastpathTV.EncMapIntfInt32V(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]int64:
-		fastpathTV.EncMapIntfInt64V(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]int64:
-		fastpathTV.EncMapIntfInt64V(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]float32:
-		fastpathTV.EncMapIntfFloat32V(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]float32:
-		fastpathTV.EncMapIntfFloat32V(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]float64:
-		fastpathTV.EncMapIntfFloat64V(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]float64:
-		fastpathTV.EncMapIntfFloat64V(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]bool:
-		fastpathTV.EncMapIntfBoolV(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]bool:
-		fastpathTV.EncMapIntfBoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[string]interface{}:
-		fastpathTV.EncMapStringIntfV(v, fastpathCheckNilTrue, e)
-	case *map[string]interface{}:
-		fastpathTV.EncMapStringIntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[string]string:
-		fastpathTV.EncMapStringStringV(v, fastpathCheckNilTrue, e)
-	case *map[string]string:
-		fastpathTV.EncMapStringStringV(*v, fastpathCheckNilTrue, e)
-
-	case map[string]uint:
-		fastpathTV.EncMapStringUintV(v, fastpathCheckNilTrue, e)
-	case *map[string]uint:
-		fastpathTV.EncMapStringUintV(*v, fastpathCheckNilTrue, e)
-
-	case map[string]uint8:
-		fastpathTV.EncMapStringUint8V(v, fastpathCheckNilTrue, e)
-	case *map[string]uint8:
-		fastpathTV.EncMapStringUint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[string]uint16:
-		fastpathTV.EncMapStringUint16V(v, fastpathCheckNilTrue, e)
-	case *map[string]uint16:
-		fastpathTV.EncMapStringUint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[string]uint32:
-		fastpathTV.EncMapStringUint32V(v, fastpathCheckNilTrue, e)
-	case *map[string]uint32:
-		fastpathTV.EncMapStringUint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[string]uint64:
-		fastpathTV.EncMapStringUint64V(v, fastpathCheckNilTrue, e)
-	case *map[string]uint64:
-		fastpathTV.EncMapStringUint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[string]uintptr:
-		fastpathTV.EncMapStringUintptrV(v, fastpathCheckNilTrue, e)
-	case *map[string]uintptr:
-		fastpathTV.EncMapStringUintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[string]int:
-		fastpathTV.EncMapStringIntV(v, fastpathCheckNilTrue, e)
-	case *map[string]int:
-		fastpathTV.EncMapStringIntV(*v, fastpathCheckNilTrue, e)
-
-	case map[string]int8:
-		fastpathTV.EncMapStringInt8V(v, fastpathCheckNilTrue, e)
-	case *map[string]int8:
-		fastpathTV.EncMapStringInt8V(*v, fastpathCheckNilTrue, e)
-
-	case map[string]int16:
-		fastpathTV.EncMapStringInt16V(v, fastpathCheckNilTrue, e)
-	case *map[string]int16:
-		fastpathTV.EncMapStringInt16V(*v, fastpathCheckNilTrue, e)
-
-	case map[string]int32:
-		fastpathTV.EncMapStringInt32V(v, fastpathCheckNilTrue, e)
-	case *map[string]int32:
-		fastpathTV.EncMapStringInt32V(*v, fastpathCheckNilTrue, e)
-
-	case map[string]int64:
-		fastpathTV.EncMapStringInt64V(v, fastpathCheckNilTrue, e)
-	case *map[string]int64:
-		fastpathTV.EncMapStringInt64V(*v, fastpathCheckNilTrue, e)
-
-	case map[string]float32:
-		fastpathTV.EncMapStringFloat32V(v, fastpathCheckNilTrue, e)
-	case *map[string]float32:
-		fastpathTV.EncMapStringFloat32V(*v, fastpathCheckNilTrue, e)
-
-	case map[string]float64:
-		fastpathTV.EncMapStringFloat64V(v, fastpathCheckNilTrue, e)
-	case *map[string]float64:
-		fastpathTV.EncMapStringFloat64V(*v, fastpathCheckNilTrue, e)
-
-	case map[string]bool:
-		fastpathTV.EncMapStringBoolV(v, fastpathCheckNilTrue, e)
-	case *map[string]bool:
-		fastpathTV.EncMapStringBoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]interface{}:
-		fastpathTV.EncMapFloat32IntfV(v, fastpathCheckNilTrue, e)
-	case *map[float32]interface{}:
-		fastpathTV.EncMapFloat32IntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]string:
-		fastpathTV.EncMapFloat32StringV(v, fastpathCheckNilTrue, e)
-	case *map[float32]string:
-		fastpathTV.EncMapFloat32StringV(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]uint:
-		fastpathTV.EncMapFloat32UintV(v, fastpathCheckNilTrue, e)
-	case *map[float32]uint:
-		fastpathTV.EncMapFloat32UintV(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]uint8:
-		fastpathTV.EncMapFloat32Uint8V(v, fastpathCheckNilTrue, e)
-	case *map[float32]uint8:
-		fastpathTV.EncMapFloat32Uint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]uint16:
-		fastpathTV.EncMapFloat32Uint16V(v, fastpathCheckNilTrue, e)
-	case *map[float32]uint16:
-		fastpathTV.EncMapFloat32Uint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]uint32:
-		fastpathTV.EncMapFloat32Uint32V(v, fastpathCheckNilTrue, e)
-	case *map[float32]uint32:
-		fastpathTV.EncMapFloat32Uint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]uint64:
-		fastpathTV.EncMapFloat32Uint64V(v, fastpathCheckNilTrue, e)
-	case *map[float32]uint64:
-		fastpathTV.EncMapFloat32Uint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]uintptr:
-		fastpathTV.EncMapFloat32UintptrV(v, fastpathCheckNilTrue, e)
-	case *map[float32]uintptr:
-		fastpathTV.EncMapFloat32UintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]int:
-		fastpathTV.EncMapFloat32IntV(v, fastpathCheckNilTrue, e)
-	case *map[float32]int:
-		fastpathTV.EncMapFloat32IntV(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]int8:
-		fastpathTV.EncMapFloat32Int8V(v, fastpathCheckNilTrue, e)
-	case *map[float32]int8:
-		fastpathTV.EncMapFloat32Int8V(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]int16:
-		fastpathTV.EncMapFloat32Int16V(v, fastpathCheckNilTrue, e)
-	case *map[float32]int16:
-		fastpathTV.EncMapFloat32Int16V(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]int32:
-		fastpathTV.EncMapFloat32Int32V(v, fastpathCheckNilTrue, e)
-	case *map[float32]int32:
-		fastpathTV.EncMapFloat32Int32V(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]int64:
-		fastpathTV.EncMapFloat32Int64V(v, fastpathCheckNilTrue, e)
-	case *map[float32]int64:
-		fastpathTV.EncMapFloat32Int64V(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]float32:
-		fastpathTV.EncMapFloat32Float32V(v, fastpathCheckNilTrue, e)
-	case *map[float32]float32:
-		fastpathTV.EncMapFloat32Float32V(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]float64:
-		fastpathTV.EncMapFloat32Float64V(v, fastpathCheckNilTrue, e)
-	case *map[float32]float64:
-		fastpathTV.EncMapFloat32Float64V(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]bool:
-		fastpathTV.EncMapFloat32BoolV(v, fastpathCheckNilTrue, e)
-	case *map[float32]bool:
-		fastpathTV.EncMapFloat32BoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]interface{}:
-		fastpathTV.EncMapFloat64IntfV(v, fastpathCheckNilTrue, e)
-	case *map[float64]interface{}:
-		fastpathTV.EncMapFloat64IntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]string:
-		fastpathTV.EncMapFloat64StringV(v, fastpathCheckNilTrue, e)
-	case *map[float64]string:
-		fastpathTV.EncMapFloat64StringV(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]uint:
-		fastpathTV.EncMapFloat64UintV(v, fastpathCheckNilTrue, e)
-	case *map[float64]uint:
-		fastpathTV.EncMapFloat64UintV(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]uint8:
-		fastpathTV.EncMapFloat64Uint8V(v, fastpathCheckNilTrue, e)
-	case *map[float64]uint8:
-		fastpathTV.EncMapFloat64Uint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]uint16:
-		fastpathTV.EncMapFloat64Uint16V(v, fastpathCheckNilTrue, e)
-	case *map[float64]uint16:
-		fastpathTV.EncMapFloat64Uint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]uint32:
-		fastpathTV.EncMapFloat64Uint32V(v, fastpathCheckNilTrue, e)
-	case *map[float64]uint32:
-		fastpathTV.EncMapFloat64Uint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]uint64:
-		fastpathTV.EncMapFloat64Uint64V(v, fastpathCheckNilTrue, e)
-	case *map[float64]uint64:
-		fastpathTV.EncMapFloat64Uint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]uintptr:
-		fastpathTV.EncMapFloat64UintptrV(v, fastpathCheckNilTrue, e)
-	case *map[float64]uintptr:
-		fastpathTV.EncMapFloat64UintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]int:
-		fastpathTV.EncMapFloat64IntV(v, fastpathCheckNilTrue, e)
-	case *map[float64]int:
-		fastpathTV.EncMapFloat64IntV(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]int8:
-		fastpathTV.EncMapFloat64Int8V(v, fastpathCheckNilTrue, e)
-	case *map[float64]int8:
-		fastpathTV.EncMapFloat64Int8V(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]int16:
-		fastpathTV.EncMapFloat64Int16V(v, fastpathCheckNilTrue, e)
-	case *map[float64]int16:
-		fastpathTV.EncMapFloat64Int16V(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]int32:
-		fastpathTV.EncMapFloat64Int32V(v, fastpathCheckNilTrue, e)
-	case *map[float64]int32:
-		fastpathTV.EncMapFloat64Int32V(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]int64:
-		fastpathTV.EncMapFloat64Int64V(v, fastpathCheckNilTrue, e)
-	case *map[float64]int64:
-		fastpathTV.EncMapFloat64Int64V(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]float32:
-		fastpathTV.EncMapFloat64Float32V(v, fastpathCheckNilTrue, e)
-	case *map[float64]float32:
-		fastpathTV.EncMapFloat64Float32V(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]float64:
-		fastpathTV.EncMapFloat64Float64V(v, fastpathCheckNilTrue, e)
-	case *map[float64]float64:
-		fastpathTV.EncMapFloat64Float64V(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]bool:
-		fastpathTV.EncMapFloat64BoolV(v, fastpathCheckNilTrue, e)
-	case *map[float64]bool:
-		fastpathTV.EncMapFloat64BoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]interface{}:
-		fastpathTV.EncMapUintIntfV(v, fastpathCheckNilTrue, e)
-	case *map[uint]interface{}:
-		fastpathTV.EncMapUintIntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]string:
-		fastpathTV.EncMapUintStringV(v, fastpathCheckNilTrue, e)
-	case *map[uint]string:
-		fastpathTV.EncMapUintStringV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]uint:
-		fastpathTV.EncMapUintUintV(v, fastpathCheckNilTrue, e)
-	case *map[uint]uint:
-		fastpathTV.EncMapUintUintV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]uint8:
-		fastpathTV.EncMapUintUint8V(v, fastpathCheckNilTrue, e)
-	case *map[uint]uint8:
-		fastpathTV.EncMapUintUint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]uint16:
-		fastpathTV.EncMapUintUint16V(v, fastpathCheckNilTrue, e)
-	case *map[uint]uint16:
-		fastpathTV.EncMapUintUint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]uint32:
-		fastpathTV.EncMapUintUint32V(v, fastpathCheckNilTrue, e)
-	case *map[uint]uint32:
-		fastpathTV.EncMapUintUint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]uint64:
-		fastpathTV.EncMapUintUint64V(v, fastpathCheckNilTrue, e)
-	case *map[uint]uint64:
-		fastpathTV.EncMapUintUint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]uintptr:
-		fastpathTV.EncMapUintUintptrV(v, fastpathCheckNilTrue, e)
-	case *map[uint]uintptr:
-		fastpathTV.EncMapUintUintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]int:
-		fastpathTV.EncMapUintIntV(v, fastpathCheckNilTrue, e)
-	case *map[uint]int:
-		fastpathTV.EncMapUintIntV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]int8:
-		fastpathTV.EncMapUintInt8V(v, fastpathCheckNilTrue, e)
-	case *map[uint]int8:
-		fastpathTV.EncMapUintInt8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]int16:
-		fastpathTV.EncMapUintInt16V(v, fastpathCheckNilTrue, e)
-	case *map[uint]int16:
-		fastpathTV.EncMapUintInt16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]int32:
-		fastpathTV.EncMapUintInt32V(v, fastpathCheckNilTrue, e)
-	case *map[uint]int32:
-		fastpathTV.EncMapUintInt32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]int64:
-		fastpathTV.EncMapUintInt64V(v, fastpathCheckNilTrue, e)
-	case *map[uint]int64:
-		fastpathTV.EncMapUintInt64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]float32:
-		fastpathTV.EncMapUintFloat32V(v, fastpathCheckNilTrue, e)
-	case *map[uint]float32:
-		fastpathTV.EncMapUintFloat32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]float64:
-		fastpathTV.EncMapUintFloat64V(v, fastpathCheckNilTrue, e)
-	case *map[uint]float64:
-		fastpathTV.EncMapUintFloat64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]bool:
-		fastpathTV.EncMapUintBoolV(v, fastpathCheckNilTrue, e)
-	case *map[uint]bool:
-		fastpathTV.EncMapUintBoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]interface{}:
-		fastpathTV.EncMapUint8IntfV(v, fastpathCheckNilTrue, e)
-	case *map[uint8]interface{}:
-		fastpathTV.EncMapUint8IntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]string:
-		fastpathTV.EncMapUint8StringV(v, fastpathCheckNilTrue, e)
-	case *map[uint8]string:
-		fastpathTV.EncMapUint8StringV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]uint:
-		fastpathTV.EncMapUint8UintV(v, fastpathCheckNilTrue, e)
-	case *map[uint8]uint:
-		fastpathTV.EncMapUint8UintV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]uint8:
-		fastpathTV.EncMapUint8Uint8V(v, fastpathCheckNilTrue, e)
-	case *map[uint8]uint8:
-		fastpathTV.EncMapUint8Uint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]uint16:
-		fastpathTV.EncMapUint8Uint16V(v, fastpathCheckNilTrue, e)
-	case *map[uint8]uint16:
-		fastpathTV.EncMapUint8Uint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]uint32:
-		fastpathTV.EncMapUint8Uint32V(v, fastpathCheckNilTrue, e)
-	case *map[uint8]uint32:
-		fastpathTV.EncMapUint8Uint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]uint64:
-		fastpathTV.EncMapUint8Uint64V(v, fastpathCheckNilTrue, e)
-	case *map[uint8]uint64:
-		fastpathTV.EncMapUint8Uint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]uintptr:
-		fastpathTV.EncMapUint8UintptrV(v, fastpathCheckNilTrue, e)
-	case *map[uint8]uintptr:
-		fastpathTV.EncMapUint8UintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]int:
-		fastpathTV.EncMapUint8IntV(v, fastpathCheckNilTrue, e)
-	case *map[uint8]int:
-		fastpathTV.EncMapUint8IntV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]int8:
-		fastpathTV.EncMapUint8Int8V(v, fastpathCheckNilTrue, e)
-	case *map[uint8]int8:
-		fastpathTV.EncMapUint8Int8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]int16:
-		fastpathTV.EncMapUint8Int16V(v, fastpathCheckNilTrue, e)
-	case *map[uint8]int16:
-		fastpathTV.EncMapUint8Int16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]int32:
-		fastpathTV.EncMapUint8Int32V(v, fastpathCheckNilTrue, e)
-	case *map[uint8]int32:
-		fastpathTV.EncMapUint8Int32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]int64:
-		fastpathTV.EncMapUint8Int64V(v, fastpathCheckNilTrue, e)
-	case *map[uint8]int64:
-		fastpathTV.EncMapUint8Int64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]float32:
-		fastpathTV.EncMapUint8Float32V(v, fastpathCheckNilTrue, e)
-	case *map[uint8]float32:
-		fastpathTV.EncMapUint8Float32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]float64:
-		fastpathTV.EncMapUint8Float64V(v, fastpathCheckNilTrue, e)
-	case *map[uint8]float64:
-		fastpathTV.EncMapUint8Float64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]bool:
-		fastpathTV.EncMapUint8BoolV(v, fastpathCheckNilTrue, e)
-	case *map[uint8]bool:
-		fastpathTV.EncMapUint8BoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]interface{}:
-		fastpathTV.EncMapUint16IntfV(v, fastpathCheckNilTrue, e)
-	case *map[uint16]interface{}:
-		fastpathTV.EncMapUint16IntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]string:
-		fastpathTV.EncMapUint16StringV(v, fastpathCheckNilTrue, e)
-	case *map[uint16]string:
-		fastpathTV.EncMapUint16StringV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]uint:
-		fastpathTV.EncMapUint16UintV(v, fastpathCheckNilTrue, e)
-	case *map[uint16]uint:
-		fastpathTV.EncMapUint16UintV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]uint8:
-		fastpathTV.EncMapUint16Uint8V(v, fastpathCheckNilTrue, e)
-	case *map[uint16]uint8:
-		fastpathTV.EncMapUint16Uint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]uint16:
-		fastpathTV.EncMapUint16Uint16V(v, fastpathCheckNilTrue, e)
-	case *map[uint16]uint16:
-		fastpathTV.EncMapUint16Uint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]uint32:
-		fastpathTV.EncMapUint16Uint32V(v, fastpathCheckNilTrue, e)
-	case *map[uint16]uint32:
-		fastpathTV.EncMapUint16Uint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]uint64:
-		fastpathTV.EncMapUint16Uint64V(v, fastpathCheckNilTrue, e)
-	case *map[uint16]uint64:
-		fastpathTV.EncMapUint16Uint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]uintptr:
-		fastpathTV.EncMapUint16UintptrV(v, fastpathCheckNilTrue, e)
-	case *map[uint16]uintptr:
-		fastpathTV.EncMapUint16UintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]int:
-		fastpathTV.EncMapUint16IntV(v, fastpathCheckNilTrue, e)
-	case *map[uint16]int:
-		fastpathTV.EncMapUint16IntV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]int8:
-		fastpathTV.EncMapUint16Int8V(v, fastpathCheckNilTrue, e)
-	case *map[uint16]int8:
-		fastpathTV.EncMapUint16Int8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]int16:
-		fastpathTV.EncMapUint16Int16V(v, fastpathCheckNilTrue, e)
-	case *map[uint16]int16:
-		fastpathTV.EncMapUint16Int16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]int32:
-		fastpathTV.EncMapUint16Int32V(v, fastpathCheckNilTrue, e)
-	case *map[uint16]int32:
-		fastpathTV.EncMapUint16Int32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]int64:
-		fastpathTV.EncMapUint16Int64V(v, fastpathCheckNilTrue, e)
-	case *map[uint16]int64:
-		fastpathTV.EncMapUint16Int64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]float32:
-		fastpathTV.EncMapUint16Float32V(v, fastpathCheckNilTrue, e)
-	case *map[uint16]float32:
-		fastpathTV.EncMapUint16Float32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]float64:
-		fastpathTV.EncMapUint16Float64V(v, fastpathCheckNilTrue, e)
-	case *map[uint16]float64:
-		fastpathTV.EncMapUint16Float64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]bool:
-		fastpathTV.EncMapUint16BoolV(v, fastpathCheckNilTrue, e)
-	case *map[uint16]bool:
-		fastpathTV.EncMapUint16BoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]interface{}:
-		fastpathTV.EncMapUint32IntfV(v, fastpathCheckNilTrue, e)
-	case *map[uint32]interface{}:
-		fastpathTV.EncMapUint32IntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]string:
-		fastpathTV.EncMapUint32StringV(v, fastpathCheckNilTrue, e)
-	case *map[uint32]string:
-		fastpathTV.EncMapUint32StringV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]uint:
-		fastpathTV.EncMapUint32UintV(v, fastpathCheckNilTrue, e)
-	case *map[uint32]uint:
-		fastpathTV.EncMapUint32UintV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]uint8:
-		fastpathTV.EncMapUint32Uint8V(v, fastpathCheckNilTrue, e)
-	case *map[uint32]uint8:
-		fastpathTV.EncMapUint32Uint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]uint16:
-		fastpathTV.EncMapUint32Uint16V(v, fastpathCheckNilTrue, e)
-	case *map[uint32]uint16:
-		fastpathTV.EncMapUint32Uint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]uint32:
-		fastpathTV.EncMapUint32Uint32V(v, fastpathCheckNilTrue, e)
-	case *map[uint32]uint32:
-		fastpathTV.EncMapUint32Uint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]uint64:
-		fastpathTV.EncMapUint32Uint64V(v, fastpathCheckNilTrue, e)
-	case *map[uint32]uint64:
-		fastpathTV.EncMapUint32Uint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]uintptr:
-		fastpathTV.EncMapUint32UintptrV(v, fastpathCheckNilTrue, e)
-	case *map[uint32]uintptr:
-		fastpathTV.EncMapUint32UintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]int:
-		fastpathTV.EncMapUint32IntV(v, fastpathCheckNilTrue, e)
-	case *map[uint32]int:
-		fastpathTV.EncMapUint32IntV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]int8:
-		fastpathTV.EncMapUint32Int8V(v, fastpathCheckNilTrue, e)
-	case *map[uint32]int8:
-		fastpathTV.EncMapUint32Int8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]int16:
-		fastpathTV.EncMapUint32Int16V(v, fastpathCheckNilTrue, e)
-	case *map[uint32]int16:
-		fastpathTV.EncMapUint32Int16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]int32:
-		fastpathTV.EncMapUint32Int32V(v, fastpathCheckNilTrue, e)
-	case *map[uint32]int32:
-		fastpathTV.EncMapUint32Int32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]int64:
-		fastpathTV.EncMapUint32Int64V(v, fastpathCheckNilTrue, e)
-	case *map[uint32]int64:
-		fastpathTV.EncMapUint32Int64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]float32:
-		fastpathTV.EncMapUint32Float32V(v, fastpathCheckNilTrue, e)
-	case *map[uint32]float32:
-		fastpathTV.EncMapUint32Float32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]float64:
-		fastpathTV.EncMapUint32Float64V(v, fastpathCheckNilTrue, e)
-	case *map[uint32]float64:
-		fastpathTV.EncMapUint32Float64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]bool:
-		fastpathTV.EncMapUint32BoolV(v, fastpathCheckNilTrue, e)
-	case *map[uint32]bool:
-		fastpathTV.EncMapUint32BoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]interface{}:
-		fastpathTV.EncMapUint64IntfV(v, fastpathCheckNilTrue, e)
-	case *map[uint64]interface{}:
-		fastpathTV.EncMapUint64IntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]string:
-		fastpathTV.EncMapUint64StringV(v, fastpathCheckNilTrue, e)
-	case *map[uint64]string:
-		fastpathTV.EncMapUint64StringV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]uint:
-		fastpathTV.EncMapUint64UintV(v, fastpathCheckNilTrue, e)
-	case *map[uint64]uint:
-		fastpathTV.EncMapUint64UintV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]uint8:
-		fastpathTV.EncMapUint64Uint8V(v, fastpathCheckNilTrue, e)
-	case *map[uint64]uint8:
-		fastpathTV.EncMapUint64Uint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]uint16:
-		fastpathTV.EncMapUint64Uint16V(v, fastpathCheckNilTrue, e)
-	case *map[uint64]uint16:
-		fastpathTV.EncMapUint64Uint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]uint32:
-		fastpathTV.EncMapUint64Uint32V(v, fastpathCheckNilTrue, e)
-	case *map[uint64]uint32:
-		fastpathTV.EncMapUint64Uint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]uint64:
-		fastpathTV.EncMapUint64Uint64V(v, fastpathCheckNilTrue, e)
-	case *map[uint64]uint64:
-		fastpathTV.EncMapUint64Uint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]uintptr:
-		fastpathTV.EncMapUint64UintptrV(v, fastpathCheckNilTrue, e)
-	case *map[uint64]uintptr:
-		fastpathTV.EncMapUint64UintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]int:
-		fastpathTV.EncMapUint64IntV(v, fastpathCheckNilTrue, e)
-	case *map[uint64]int:
-		fastpathTV.EncMapUint64IntV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]int8:
-		fastpathTV.EncMapUint64Int8V(v, fastpathCheckNilTrue, e)
-	case *map[uint64]int8:
-		fastpathTV.EncMapUint64Int8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]int16:
-		fastpathTV.EncMapUint64Int16V(v, fastpathCheckNilTrue, e)
-	case *map[uint64]int16:
-		fastpathTV.EncMapUint64Int16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]int32:
-		fastpathTV.EncMapUint64Int32V(v, fastpathCheckNilTrue, e)
-	case *map[uint64]int32:
-		fastpathTV.EncMapUint64Int32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]int64:
-		fastpathTV.EncMapUint64Int64V(v, fastpathCheckNilTrue, e)
-	case *map[uint64]int64:
-		fastpathTV.EncMapUint64Int64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]float32:
-		fastpathTV.EncMapUint64Float32V(v, fastpathCheckNilTrue, e)
-	case *map[uint64]float32:
-		fastpathTV.EncMapUint64Float32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]float64:
-		fastpathTV.EncMapUint64Float64V(v, fastpathCheckNilTrue, e)
-	case *map[uint64]float64:
-		fastpathTV.EncMapUint64Float64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]bool:
-		fastpathTV.EncMapUint64BoolV(v, fastpathCheckNilTrue, e)
-	case *map[uint64]bool:
-		fastpathTV.EncMapUint64BoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]interface{}:
-		fastpathTV.EncMapUintptrIntfV(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]interface{}:
-		fastpathTV.EncMapUintptrIntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]string:
-		fastpathTV.EncMapUintptrStringV(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]string:
-		fastpathTV.EncMapUintptrStringV(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]uint:
-		fastpathTV.EncMapUintptrUintV(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]uint:
-		fastpathTV.EncMapUintptrUintV(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]uint8:
-		fastpathTV.EncMapUintptrUint8V(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]uint8:
-		fastpathTV.EncMapUintptrUint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]uint16:
-		fastpathTV.EncMapUintptrUint16V(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]uint16:
-		fastpathTV.EncMapUintptrUint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]uint32:
-		fastpathTV.EncMapUintptrUint32V(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]uint32:
-		fastpathTV.EncMapUintptrUint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]uint64:
-		fastpathTV.EncMapUintptrUint64V(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]uint64:
-		fastpathTV.EncMapUintptrUint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]uintptr:
-		fastpathTV.EncMapUintptrUintptrV(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]uintptr:
-		fastpathTV.EncMapUintptrUintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]int:
-		fastpathTV.EncMapUintptrIntV(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]int:
-		fastpathTV.EncMapUintptrIntV(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]int8:
-		fastpathTV.EncMapUintptrInt8V(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]int8:
-		fastpathTV.EncMapUintptrInt8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]int16:
-		fastpathTV.EncMapUintptrInt16V(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]int16:
-		fastpathTV.EncMapUintptrInt16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]int32:
-		fastpathTV.EncMapUintptrInt32V(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]int32:
-		fastpathTV.EncMapUintptrInt32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]int64:
-		fastpathTV.EncMapUintptrInt64V(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]int64:
-		fastpathTV.EncMapUintptrInt64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]float32:
-		fastpathTV.EncMapUintptrFloat32V(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]float32:
-		fastpathTV.EncMapUintptrFloat32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]float64:
-		fastpathTV.EncMapUintptrFloat64V(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]float64:
-		fastpathTV.EncMapUintptrFloat64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]bool:
-		fastpathTV.EncMapUintptrBoolV(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]bool:
-		fastpathTV.EncMapUintptrBoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[int]interface{}:
-		fastpathTV.EncMapIntIntfV(v, fastpathCheckNilTrue, e)
-	case *map[int]interface{}:
-		fastpathTV.EncMapIntIntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[int]string:
-		fastpathTV.EncMapIntStringV(v, fastpathCheckNilTrue, e)
-	case *map[int]string:
-		fastpathTV.EncMapIntStringV(*v, fastpathCheckNilTrue, e)
-
-	case map[int]uint:
-		fastpathTV.EncMapIntUintV(v, fastpathCheckNilTrue, e)
-	case *map[int]uint:
-		fastpathTV.EncMapIntUintV(*v, fastpathCheckNilTrue, e)
-
-	case map[int]uint8:
-		fastpathTV.EncMapIntUint8V(v, fastpathCheckNilTrue, e)
-	case *map[int]uint8:
-		fastpathTV.EncMapIntUint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[int]uint16:
-		fastpathTV.EncMapIntUint16V(v, fastpathCheckNilTrue, e)
-	case *map[int]uint16:
-		fastpathTV.EncMapIntUint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[int]uint32:
-		fastpathTV.EncMapIntUint32V(v, fastpathCheckNilTrue, e)
-	case *map[int]uint32:
-		fastpathTV.EncMapIntUint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int]uint64:
-		fastpathTV.EncMapIntUint64V(v, fastpathCheckNilTrue, e)
-	case *map[int]uint64:
-		fastpathTV.EncMapIntUint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int]uintptr:
-		fastpathTV.EncMapIntUintptrV(v, fastpathCheckNilTrue, e)
-	case *map[int]uintptr:
-		fastpathTV.EncMapIntUintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[int]int:
-		fastpathTV.EncMapIntIntV(v, fastpathCheckNilTrue, e)
-	case *map[int]int:
-		fastpathTV.EncMapIntIntV(*v, fastpathCheckNilTrue, e)
-
-	case map[int]int8:
-		fastpathTV.EncMapIntInt8V(v, fastpathCheckNilTrue, e)
-	case *map[int]int8:
-		fastpathTV.EncMapIntInt8V(*v, fastpathCheckNilTrue, e)
-
-	case map[int]int16:
-		fastpathTV.EncMapIntInt16V(v, fastpathCheckNilTrue, e)
-	case *map[int]int16:
-		fastpathTV.EncMapIntInt16V(*v, fastpathCheckNilTrue, e)
-
-	case map[int]int32:
-		fastpathTV.EncMapIntInt32V(v, fastpathCheckNilTrue, e)
-	case *map[int]int32:
-		fastpathTV.EncMapIntInt32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int]int64:
-		fastpathTV.EncMapIntInt64V(v, fastpathCheckNilTrue, e)
-	case *map[int]int64:
-		fastpathTV.EncMapIntInt64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int]float32:
-		fastpathTV.EncMapIntFloat32V(v, fastpathCheckNilTrue, e)
-	case *map[int]float32:
-		fastpathTV.EncMapIntFloat32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int]float64:
-		fastpathTV.EncMapIntFloat64V(v, fastpathCheckNilTrue, e)
-	case *map[int]float64:
-		fastpathTV.EncMapIntFloat64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int]bool:
-		fastpathTV.EncMapIntBoolV(v, fastpathCheckNilTrue, e)
-	case *map[int]bool:
-		fastpathTV.EncMapIntBoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]interface{}:
-		fastpathTV.EncMapInt8IntfV(v, fastpathCheckNilTrue, e)
-	case *map[int8]interface{}:
-		fastpathTV.EncMapInt8IntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]string:
-		fastpathTV.EncMapInt8StringV(v, fastpathCheckNilTrue, e)
-	case *map[int8]string:
-		fastpathTV.EncMapInt8StringV(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]uint:
-		fastpathTV.EncMapInt8UintV(v, fastpathCheckNilTrue, e)
-	case *map[int8]uint:
-		fastpathTV.EncMapInt8UintV(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]uint8:
-		fastpathTV.EncMapInt8Uint8V(v, fastpathCheckNilTrue, e)
-	case *map[int8]uint8:
-		fastpathTV.EncMapInt8Uint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]uint16:
-		fastpathTV.EncMapInt8Uint16V(v, fastpathCheckNilTrue, e)
-	case *map[int8]uint16:
-		fastpathTV.EncMapInt8Uint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]uint32:
-		fastpathTV.EncMapInt8Uint32V(v, fastpathCheckNilTrue, e)
-	case *map[int8]uint32:
-		fastpathTV.EncMapInt8Uint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]uint64:
-		fastpathTV.EncMapInt8Uint64V(v, fastpathCheckNilTrue, e)
-	case *map[int8]uint64:
-		fastpathTV.EncMapInt8Uint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]uintptr:
-		fastpathTV.EncMapInt8UintptrV(v, fastpathCheckNilTrue, e)
-	case *map[int8]uintptr:
-		fastpathTV.EncMapInt8UintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]int:
-		fastpathTV.EncMapInt8IntV(v, fastpathCheckNilTrue, e)
-	case *map[int8]int:
-		fastpathTV.EncMapInt8IntV(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]int8:
-		fastpathTV.EncMapInt8Int8V(v, fastpathCheckNilTrue, e)
-	case *map[int8]int8:
-		fastpathTV.EncMapInt8Int8V(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]int16:
-		fastpathTV.EncMapInt8Int16V(v, fastpathCheckNilTrue, e)
-	case *map[int8]int16:
-		fastpathTV.EncMapInt8Int16V(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]int32:
-		fastpathTV.EncMapInt8Int32V(v, fastpathCheckNilTrue, e)
-	case *map[int8]int32:
-		fastpathTV.EncMapInt8Int32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]int64:
-		fastpathTV.EncMapInt8Int64V(v, fastpathCheckNilTrue, e)
-	case *map[int8]int64:
-		fastpathTV.EncMapInt8Int64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]float32:
-		fastpathTV.EncMapInt8Float32V(v, fastpathCheckNilTrue, e)
-	case *map[int8]float32:
-		fastpathTV.EncMapInt8Float32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]float64:
-		fastpathTV.EncMapInt8Float64V(v, fastpathCheckNilTrue, e)
-	case *map[int8]float64:
-		fastpathTV.EncMapInt8Float64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]bool:
-		fastpathTV.EncMapInt8BoolV(v, fastpathCheckNilTrue, e)
-	case *map[int8]bool:
-		fastpathTV.EncMapInt8BoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]interface{}:
-		fastpathTV.EncMapInt16IntfV(v, fastpathCheckNilTrue, e)
-	case *map[int16]interface{}:
-		fastpathTV.EncMapInt16IntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]string:
-		fastpathTV.EncMapInt16StringV(v, fastpathCheckNilTrue, e)
-	case *map[int16]string:
-		fastpathTV.EncMapInt16StringV(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]uint:
-		fastpathTV.EncMapInt16UintV(v, fastpathCheckNilTrue, e)
-	case *map[int16]uint:
-		fastpathTV.EncMapInt16UintV(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]uint8:
-		fastpathTV.EncMapInt16Uint8V(v, fastpathCheckNilTrue, e)
-	case *map[int16]uint8:
-		fastpathTV.EncMapInt16Uint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]uint16:
-		fastpathTV.EncMapInt16Uint16V(v, fastpathCheckNilTrue, e)
-	case *map[int16]uint16:
-		fastpathTV.EncMapInt16Uint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]uint32:
-		fastpathTV.EncMapInt16Uint32V(v, fastpathCheckNilTrue, e)
-	case *map[int16]uint32:
-		fastpathTV.EncMapInt16Uint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]uint64:
-		fastpathTV.EncMapInt16Uint64V(v, fastpathCheckNilTrue, e)
-	case *map[int16]uint64:
-		fastpathTV.EncMapInt16Uint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]uintptr:
-		fastpathTV.EncMapInt16UintptrV(v, fastpathCheckNilTrue, e)
-	case *map[int16]uintptr:
-		fastpathTV.EncMapInt16UintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]int:
-		fastpathTV.EncMapInt16IntV(v, fastpathCheckNilTrue, e)
-	case *map[int16]int:
-		fastpathTV.EncMapInt16IntV(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]int8:
-		fastpathTV.EncMapInt16Int8V(v, fastpathCheckNilTrue, e)
-	case *map[int16]int8:
-		fastpathTV.EncMapInt16Int8V(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]int16:
-		fastpathTV.EncMapInt16Int16V(v, fastpathCheckNilTrue, e)
-	case *map[int16]int16:
-		fastpathTV.EncMapInt16Int16V(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]int32:
-		fastpathTV.EncMapInt16Int32V(v, fastpathCheckNilTrue, e)
-	case *map[int16]int32:
-		fastpathTV.EncMapInt16Int32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]int64:
-		fastpathTV.EncMapInt16Int64V(v, fastpathCheckNilTrue, e)
-	case *map[int16]int64:
-		fastpathTV.EncMapInt16Int64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]float32:
-		fastpathTV.EncMapInt16Float32V(v, fastpathCheckNilTrue, e)
-	case *map[int16]float32:
-		fastpathTV.EncMapInt16Float32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]float64:
-		fastpathTV.EncMapInt16Float64V(v, fastpathCheckNilTrue, e)
-	case *map[int16]float64:
-		fastpathTV.EncMapInt16Float64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]bool:
-		fastpathTV.EncMapInt16BoolV(v, fastpathCheckNilTrue, e)
-	case *map[int16]bool:
-		fastpathTV.EncMapInt16BoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]interface{}:
-		fastpathTV.EncMapInt32IntfV(v, fastpathCheckNilTrue, e)
-	case *map[int32]interface{}:
-		fastpathTV.EncMapInt32IntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]string:
-		fastpathTV.EncMapInt32StringV(v, fastpathCheckNilTrue, e)
-	case *map[int32]string:
-		fastpathTV.EncMapInt32StringV(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]uint:
-		fastpathTV.EncMapInt32UintV(v, fastpathCheckNilTrue, e)
-	case *map[int32]uint:
-		fastpathTV.EncMapInt32UintV(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]uint8:
-		fastpathTV.EncMapInt32Uint8V(v, fastpathCheckNilTrue, e)
-	case *map[int32]uint8:
-		fastpathTV.EncMapInt32Uint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]uint16:
-		fastpathTV.EncMapInt32Uint16V(v, fastpathCheckNilTrue, e)
-	case *map[int32]uint16:
-		fastpathTV.EncMapInt32Uint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]uint32:
-		fastpathTV.EncMapInt32Uint32V(v, fastpathCheckNilTrue, e)
-	case *map[int32]uint32:
-		fastpathTV.EncMapInt32Uint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]uint64:
-		fastpathTV.EncMapInt32Uint64V(v, fastpathCheckNilTrue, e)
-	case *map[int32]uint64:
-		fastpathTV.EncMapInt32Uint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]uintptr:
-		fastpathTV.EncMapInt32UintptrV(v, fastpathCheckNilTrue, e)
-	case *map[int32]uintptr:
-		fastpathTV.EncMapInt32UintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]int:
-		fastpathTV.EncMapInt32IntV(v, fastpathCheckNilTrue, e)
-	case *map[int32]int:
-		fastpathTV.EncMapInt32IntV(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]int8:
-		fastpathTV.EncMapInt32Int8V(v, fastpathCheckNilTrue, e)
-	case *map[int32]int8:
-		fastpathTV.EncMapInt32Int8V(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]int16:
-		fastpathTV.EncMapInt32Int16V(v, fastpathCheckNilTrue, e)
-	case *map[int32]int16:
-		fastpathTV.EncMapInt32Int16V(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]int32:
-		fastpathTV.EncMapInt32Int32V(v, fastpathCheckNilTrue, e)
-	case *map[int32]int32:
-		fastpathTV.EncMapInt32Int32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]int64:
-		fastpathTV.EncMapInt32Int64V(v, fastpathCheckNilTrue, e)
-	case *map[int32]int64:
-		fastpathTV.EncMapInt32Int64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]float32:
-		fastpathTV.EncMapInt32Float32V(v, fastpathCheckNilTrue, e)
-	case *map[int32]float32:
-		fastpathTV.EncMapInt32Float32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]float64:
-		fastpathTV.EncMapInt32Float64V(v, fastpathCheckNilTrue, e)
-	case *map[int32]float64:
-		fastpathTV.EncMapInt32Float64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]bool:
-		fastpathTV.EncMapInt32BoolV(v, fastpathCheckNilTrue, e)
-	case *map[int32]bool:
-		fastpathTV.EncMapInt32BoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]interface{}:
-		fastpathTV.EncMapInt64IntfV(v, fastpathCheckNilTrue, e)
-	case *map[int64]interface{}:
-		fastpathTV.EncMapInt64IntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]string:
-		fastpathTV.EncMapInt64StringV(v, fastpathCheckNilTrue, e)
-	case *map[int64]string:
-		fastpathTV.EncMapInt64StringV(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]uint:
-		fastpathTV.EncMapInt64UintV(v, fastpathCheckNilTrue, e)
-	case *map[int64]uint:
-		fastpathTV.EncMapInt64UintV(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]uint8:
-		fastpathTV.EncMapInt64Uint8V(v, fastpathCheckNilTrue, e)
-	case *map[int64]uint8:
-		fastpathTV.EncMapInt64Uint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]uint16:
-		fastpathTV.EncMapInt64Uint16V(v, fastpathCheckNilTrue, e)
-	case *map[int64]uint16:
-		fastpathTV.EncMapInt64Uint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]uint32:
-		fastpathTV.EncMapInt64Uint32V(v, fastpathCheckNilTrue, e)
-	case *map[int64]uint32:
-		fastpathTV.EncMapInt64Uint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]uint64:
-		fastpathTV.EncMapInt64Uint64V(v, fastpathCheckNilTrue, e)
-	case *map[int64]uint64:
-		fastpathTV.EncMapInt64Uint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]uintptr:
-		fastpathTV.EncMapInt64UintptrV(v, fastpathCheckNilTrue, e)
-	case *map[int64]uintptr:
-		fastpathTV.EncMapInt64UintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]int:
-		fastpathTV.EncMapInt64IntV(v, fastpathCheckNilTrue, e)
-	case *map[int64]int:
-		fastpathTV.EncMapInt64IntV(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]int8:
-		fastpathTV.EncMapInt64Int8V(v, fastpathCheckNilTrue, e)
-	case *map[int64]int8:
-		fastpathTV.EncMapInt64Int8V(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]int16:
-		fastpathTV.EncMapInt64Int16V(v, fastpathCheckNilTrue, e)
-	case *map[int64]int16:
-		fastpathTV.EncMapInt64Int16V(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]int32:
-		fastpathTV.EncMapInt64Int32V(v, fastpathCheckNilTrue, e)
-	case *map[int64]int32:
-		fastpathTV.EncMapInt64Int32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]int64:
-		fastpathTV.EncMapInt64Int64V(v, fastpathCheckNilTrue, e)
-	case *map[int64]int64:
-		fastpathTV.EncMapInt64Int64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]float32:
-		fastpathTV.EncMapInt64Float32V(v, fastpathCheckNilTrue, e)
-	case *map[int64]float32:
-		fastpathTV.EncMapInt64Float32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]float64:
-		fastpathTV.EncMapInt64Float64V(v, fastpathCheckNilTrue, e)
-	case *map[int64]float64:
-		fastpathTV.EncMapInt64Float64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]bool:
-		fastpathTV.EncMapInt64BoolV(v, fastpathCheckNilTrue, e)
-	case *map[int64]bool:
-		fastpathTV.EncMapInt64BoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]interface{}:
-		fastpathTV.EncMapBoolIntfV(v, fastpathCheckNilTrue, e)
-	case *map[bool]interface{}:
-		fastpathTV.EncMapBoolIntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]string:
-		fastpathTV.EncMapBoolStringV(v, fastpathCheckNilTrue, e)
-	case *map[bool]string:
-		fastpathTV.EncMapBoolStringV(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]uint:
-		fastpathTV.EncMapBoolUintV(v, fastpathCheckNilTrue, e)
-	case *map[bool]uint:
-		fastpathTV.EncMapBoolUintV(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]uint8:
-		fastpathTV.EncMapBoolUint8V(v, fastpathCheckNilTrue, e)
-	case *map[bool]uint8:
-		fastpathTV.EncMapBoolUint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]uint16:
-		fastpathTV.EncMapBoolUint16V(v, fastpathCheckNilTrue, e)
-	case *map[bool]uint16:
-		fastpathTV.EncMapBoolUint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]uint32:
-		fastpathTV.EncMapBoolUint32V(v, fastpathCheckNilTrue, e)
-	case *map[bool]uint32:
-		fastpathTV.EncMapBoolUint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]uint64:
-		fastpathTV.EncMapBoolUint64V(v, fastpathCheckNilTrue, e)
-	case *map[bool]uint64:
-		fastpathTV.EncMapBoolUint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]uintptr:
-		fastpathTV.EncMapBoolUintptrV(v, fastpathCheckNilTrue, e)
-	case *map[bool]uintptr:
-		fastpathTV.EncMapBoolUintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]int:
-		fastpathTV.EncMapBoolIntV(v, fastpathCheckNilTrue, e)
-	case *map[bool]int:
-		fastpathTV.EncMapBoolIntV(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]int8:
-		fastpathTV.EncMapBoolInt8V(v, fastpathCheckNilTrue, e)
-	case *map[bool]int8:
-		fastpathTV.EncMapBoolInt8V(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]int16:
-		fastpathTV.EncMapBoolInt16V(v, fastpathCheckNilTrue, e)
-	case *map[bool]int16:
-		fastpathTV.EncMapBoolInt16V(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]int32:
-		fastpathTV.EncMapBoolInt32V(v, fastpathCheckNilTrue, e)
-	case *map[bool]int32:
-		fastpathTV.EncMapBoolInt32V(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]int64:
-		fastpathTV.EncMapBoolInt64V(v, fastpathCheckNilTrue, e)
-	case *map[bool]int64:
-		fastpathTV.EncMapBoolInt64V(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]float32:
-		fastpathTV.EncMapBoolFloat32V(v, fastpathCheckNilTrue, e)
-	case *map[bool]float32:
-		fastpathTV.EncMapBoolFloat32V(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]float64:
-		fastpathTV.EncMapBoolFloat64V(v, fastpathCheckNilTrue, e)
-	case *map[bool]float64:
-		fastpathTV.EncMapBoolFloat64V(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]bool:
-		fastpathTV.EncMapBoolBoolV(v, fastpathCheckNilTrue, e)
-	case *map[bool]bool:
-		fastpathTV.EncMapBoolBoolV(*v, fastpathCheckNilTrue, e)
+		fastpathTV.EncMapBoolBoolV(*v, e)
 
 	default:
 		_ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
@@ -3113,812 +1465,688 @@ func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool {
 
 // -- -- fast path functions
 
-func (f *encFnInfo) fastpathEncSliceIntfR(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceIntfR(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceIntfV(rv2i(rv).([]interface{}), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceIntfV(rv2i(rv).([]interface{}), e)
 	} else {
-		fastpathTV.EncSliceIntfV(rv2i(rv).([]interface{}), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceIntfV(rv2i(rv).([]interface{}), e)
 	}
 }
-func (_ fastpathT) EncSliceIntfV(v []interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncSliceIntfV(v []interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeArrayStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		e.encode(v2)
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
-
-func (_ fastpathT) EncAsMapSliceIntfV(v []interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceIntfV(v []interface{}, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		e.encode(v2)
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceStringR(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceStringR(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceStringV(rv2i(rv).([]string), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceStringV(rv2i(rv).([]string), e)
 	} else {
-		fastpathTV.EncSliceStringV(rv2i(rv).([]string), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceStringV(rv2i(rv).([]string), e)
 	}
 }
-func (_ fastpathT) EncSliceStringV(v []string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncSliceStringV(v []string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeArrayStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
-		ee.EncodeString(c_UTF8, v2)
-	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
+		ee.EncodeString(cUTF8, v2)
 	}
+	ee.WriteArrayEnd()
 }
-
-func (_ fastpathT) EncAsMapSliceStringV(v []string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceStringV(v []string, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
-		ee.EncodeString(c_UTF8, v2)
-	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
+		ee.EncodeString(cUTF8, v2)
 	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceFloat32R(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceFloat32R(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceFloat32V(rv2i(rv).([]float32), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceFloat32V(rv2i(rv).([]float32), e)
 	} else {
-		fastpathTV.EncSliceFloat32V(rv2i(rv).([]float32), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceFloat32V(rv2i(rv).([]float32), e)
 	}
 }
-func (_ fastpathT) EncSliceFloat32V(v []float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncSliceFloat32V(v []float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeArrayStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeFloat32(v2)
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
-
-func (_ fastpathT) EncAsMapSliceFloat32V(v []float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceFloat32V(v []float32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeFloat32(v2)
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceFloat64R(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceFloat64R(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceFloat64V(rv2i(rv).([]float64), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceFloat64V(rv2i(rv).([]float64), e)
 	} else {
-		fastpathTV.EncSliceFloat64V(rv2i(rv).([]float64), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceFloat64V(rv2i(rv).([]float64), e)
 	}
 }
-func (_ fastpathT) EncSliceFloat64V(v []float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncSliceFloat64V(v []float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeArrayStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeFloat64(v2)
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
-
-func (_ fastpathT) EncAsMapSliceFloat64V(v []float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceFloat64V(v []float64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeFloat64(v2)
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceUintR(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceUintR(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceUintV(rv2i(rv).([]uint), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceUintV(rv2i(rv).([]uint), e)
 	} else {
-		fastpathTV.EncSliceUintV(rv2i(rv).([]uint), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceUintV(rv2i(rv).([]uint), e)
 	}
 }
-func (_ fastpathT) EncSliceUintV(v []uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncSliceUintV(v []uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeArrayStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeUint(uint64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
-
-func (_ fastpathT) EncAsMapSliceUintV(v []uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceUintV(v []uint, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeUint(uint64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceUint16R(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceUint8R(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceUint16V(rv2i(rv).([]uint16), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceUint8V(rv2i(rv).([]uint8), e)
 	} else {
-		fastpathTV.EncSliceUint16V(rv2i(rv).([]uint16), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceUint8V(rv2i(rv).([]uint8), e)
 	}
 }
-func (_ fastpathT) EncSliceUint16V(v []uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncSliceUint8V(v []uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeArrayStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeUint(uint64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
-
-func (_ fastpathT) EncAsMapSliceUint16V(v []uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceUint8V(v []uint8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeUint(uint64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceUint32R(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceUint16R(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceUint32V(rv2i(rv).([]uint32), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceUint16V(rv2i(rv).([]uint16), e)
 	} else {
-		fastpathTV.EncSliceUint32V(rv2i(rv).([]uint32), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceUint16V(rv2i(rv).([]uint16), e)
 	}
 }
-func (_ fastpathT) EncSliceUint32V(v []uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncSliceUint16V(v []uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeArrayStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeUint(uint64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
-
-func (_ fastpathT) EncAsMapSliceUint32V(v []uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceUint16V(v []uint16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeUint(uint64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceUint64R(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceUint32R(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceUint64V(rv2i(rv).([]uint64), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceUint32V(rv2i(rv).([]uint32), e)
 	} else {
-		fastpathTV.EncSliceUint64V(rv2i(rv).([]uint64), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceUint32V(rv2i(rv).([]uint32), e)
 	}
 }
-func (_ fastpathT) EncSliceUint64V(v []uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncSliceUint32V(v []uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeArrayStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeUint(uint64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
-
-func (_ fastpathT) EncAsMapSliceUint64V(v []uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceUint32V(v []uint32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeUint(uint64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceUintptrR(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceUint64R(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceUintptrV(rv2i(rv).([]uintptr), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceUint64V(rv2i(rv).([]uint64), e)
 	} else {
-		fastpathTV.EncSliceUintptrV(rv2i(rv).([]uintptr), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceUint64V(rv2i(rv).([]uint64), e)
 	}
 }
-func (_ fastpathT) EncSliceUintptrV(v []uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncSliceUint64V(v []uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeArrayStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
+		}
+		ee.EncodeUint(uint64(v2))
+	}
+	ee.WriteArrayEnd()
+}
+func (_ fastpathT) EncAsMapSliceUint64V(v []uint64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	if len(v)%2 == 1 {
+		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
+		return
+	}
+	ee.WriteMapStart(len(v) / 2)
+	for j, v2 := range v {
+		if esep {
+			if j%2 == 0 {
+				ee.WriteMapElemKey()
+			} else {
+				ee.WriteMapElemValue()
+			}
+		}
+		ee.EncodeUint(uint64(v2))
+	}
+	ee.WriteMapEnd()
+}
+
+func (e *Encoder) fastpathEncSliceUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if f.ti.mbs {
+		fastpathTV.EncAsMapSliceUintptrV(rv2i(rv).([]uintptr), e)
+	} else {
+		fastpathTV.EncSliceUintptrV(rv2i(rv).([]uintptr), e)
+	}
+}
+func (_ fastpathT) EncSliceUintptrV(v []uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
+		return
+	}
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
+	for _, v2 := range v {
+		if esep {
+			ee.WriteArrayElem()
 		}
 		e.encode(v2)
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
-
-func (_ fastpathT) EncAsMapSliceUintptrV(v []uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceUintptrV(v []uintptr, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		e.encode(v2)
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceIntR(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceIntR(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceIntV(rv2i(rv).([]int), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceIntV(rv2i(rv).([]int), e)
 	} else {
-		fastpathTV.EncSliceIntV(rv2i(rv).([]int), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceIntV(rv2i(rv).([]int), e)
 	}
 }
-func (_ fastpathT) EncSliceIntV(v []int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncSliceIntV(v []int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeArrayStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeInt(int64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
-
-func (_ fastpathT) EncAsMapSliceIntV(v []int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceIntV(v []int, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeInt(int64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceInt8R(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceInt8R(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceInt8V(rv2i(rv).([]int8), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceInt8V(rv2i(rv).([]int8), e)
 	} else {
-		fastpathTV.EncSliceInt8V(rv2i(rv).([]int8), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceInt8V(rv2i(rv).([]int8), e)
 	}
 }
-func (_ fastpathT) EncSliceInt8V(v []int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncSliceInt8V(v []int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeArrayStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeInt(int64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
-
-func (_ fastpathT) EncAsMapSliceInt8V(v []int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceInt8V(v []int8, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeInt(int64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceInt16R(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceInt16R(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceInt16V(rv2i(rv).([]int16), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceInt16V(rv2i(rv).([]int16), e)
 	} else {
-		fastpathTV.EncSliceInt16V(rv2i(rv).([]int16), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceInt16V(rv2i(rv).([]int16), e)
 	}
 }
-func (_ fastpathT) EncSliceInt16V(v []int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncSliceInt16V(v []int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeArrayStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeInt(int64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
-
-func (_ fastpathT) EncAsMapSliceInt16V(v []int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceInt16V(v []int16, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeInt(int64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceInt32R(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceInt32R(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceInt32V(rv2i(rv).([]int32), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceInt32V(rv2i(rv).([]int32), e)
 	} else {
-		fastpathTV.EncSliceInt32V(rv2i(rv).([]int32), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceInt32V(rv2i(rv).([]int32), e)
 	}
 }
-func (_ fastpathT) EncSliceInt32V(v []int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncSliceInt32V(v []int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeArrayStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeInt(int64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
-
-func (_ fastpathT) EncAsMapSliceInt32V(v []int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceInt32V(v []int32, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeInt(int64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceInt64R(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceInt64R(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceInt64V(rv2i(rv).([]int64), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceInt64V(rv2i(rv).([]int64), e)
 	} else {
-		fastpathTV.EncSliceInt64V(rv2i(rv).([]int64), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceInt64V(rv2i(rv).([]int64), e)
 	}
 }
-func (_ fastpathT) EncSliceInt64V(v []int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncSliceInt64V(v []int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeArrayStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeInt(int64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
-
-func (_ fastpathT) EncAsMapSliceInt64V(v []int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceInt64V(v []int64, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeInt(int64(v2))
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncSliceBoolR(rv reflect.Value) {
+func (e *Encoder) fastpathEncSliceBoolR(f *codecFnInfo, rv reflect.Value) {
 	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceBoolV(rv2i(rv).([]bool), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncAsMapSliceBoolV(rv2i(rv).([]bool), e)
 	} else {
-		fastpathTV.EncSliceBoolV(rv2i(rv).([]bool), fastpathCheckNilFalse, f.e)
+		fastpathTV.EncSliceBoolV(rv2i(rv).([]bool), e)
 	}
 }
-func (_ fastpathT) EncSliceBoolV(v []bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncSliceBoolV(v []bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeArrayStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
 	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		if esep {
+			ee.WriteArrayElem()
 		}
 		ee.EncodeBool(v2)
 	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
-	}
+	ee.WriteArrayEnd()
 }
-
-func (_ fastpathT) EncAsMapSliceBoolV(v []bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
+func (_ fastpathT) EncAsMapSliceBoolV(v []bool, e *Encoder) {
+	ee, esep := e.e, e.hh.hasElemSeparators()
 	if len(v)%2 == 1 {
 		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
 		return
 	}
-	ee.EncodeMapStart(len(v) / 2)
+	ee.WriteMapStart(len(v) / 2)
 	for j, v2 := range v {
-		if cr != nil {
+		if esep {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
 		}
 		ee.EncodeBool(v2)
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfIntfR(rv reflect.Value) {
-	fastpathTV.EncMapIntfIntfV(rv2i(rv).(map[interface{}]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfIntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfIntfV(rv2i(rv).(map[interface{}]interface{}), e)
 }
-func (_ fastpathT) EncMapIntfIntfV(v map[interface{}]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntfIntfV(v map[interface{}]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -3935,43 +2163,40 @@ func (_ fastpathT) EncMapIntfIntfV(v map[interface{}]interface{}, checkNil bool,
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfStringR(rv reflect.Value) {
-	fastpathTV.EncMapIntfStringV(rv2i(rv).(map[interface{}]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfStringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfStringV(rv2i(rv).(map[interface{}]string), e)
 }
-func (_ fastpathT) EncMapIntfStringV(v map[interface{}]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntfStringV(v map[interface{}]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -3988,43 +2213,40 @@ func (_ fastpathT) EncMapIntfStringV(v map[interface{}]string, checkNil bool, e
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v2)
+			ee.EncodeString(cUTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfUintR(rv reflect.Value) {
-	fastpathTV.EncMapIntfUintV(rv2i(rv).(map[interface{}]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfUintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfUintV(rv2i(rv).(map[interface{}]uint), e)
 }
-func (_ fastpathT) EncMapIntfUintV(v map[interface{}]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntfUintV(v map[interface{}]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4041,43 +2263,40 @@ func (_ fastpathT) EncMapIntfUintV(v map[interface{}]uint, checkNil bool, e *Enc
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfUint8R(rv reflect.Value) {
-	fastpathTV.EncMapIntfUint8V(rv2i(rv).(map[interface{}]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfUint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfUint8V(rv2i(rv).(map[interface{}]uint8), e)
 }
-func (_ fastpathT) EncMapIntfUint8V(v map[interface{}]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntfUint8V(v map[interface{}]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4094,43 +2313,40 @@ func (_ fastpathT) EncMapIntfUint8V(v map[interface{}]uint8, checkNil bool, e *E
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfUint16R(rv reflect.Value) {
-	fastpathTV.EncMapIntfUint16V(rv2i(rv).(map[interface{}]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfUint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfUint16V(rv2i(rv).(map[interface{}]uint16), e)
 }
-func (_ fastpathT) EncMapIntfUint16V(v map[interface{}]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntfUint16V(v map[interface{}]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4147,43 +2363,40 @@ func (_ fastpathT) EncMapIntfUint16V(v map[interface{}]uint16, checkNil bool, e
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfUint32R(rv reflect.Value) {
-	fastpathTV.EncMapIntfUint32V(rv2i(rv).(map[interface{}]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfUint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfUint32V(rv2i(rv).(map[interface{}]uint32), e)
 }
-func (_ fastpathT) EncMapIntfUint32V(v map[interface{}]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntfUint32V(v map[interface{}]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4200,43 +2413,40 @@ func (_ fastpathT) EncMapIntfUint32V(v map[interface{}]uint32, checkNil bool, e
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfUint64R(rv reflect.Value) {
-	fastpathTV.EncMapIntfUint64V(rv2i(rv).(map[interface{}]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfUint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfUint64V(rv2i(rv).(map[interface{}]uint64), e)
 }
-func (_ fastpathT) EncMapIntfUint64V(v map[interface{}]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntfUint64V(v map[interface{}]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4253,43 +2463,40 @@ func (_ fastpathT) EncMapIntfUint64V(v map[interface{}]uint64, checkNil bool, e
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfUintptrR(rv reflect.Value) {
-	fastpathTV.EncMapIntfUintptrV(rv2i(rv).(map[interface{}]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfUintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfUintptrV(rv2i(rv).(map[interface{}]uintptr), e)
 }
-func (_ fastpathT) EncMapIntfUintptrV(v map[interface{}]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntfUintptrV(v map[interface{}]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4306,43 +2513,40 @@ func (_ fastpathT) EncMapIntfUintptrV(v map[interface{}]uintptr, checkNil bool,
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfIntR(rv reflect.Value) {
-	fastpathTV.EncMapIntfIntV(rv2i(rv).(map[interface{}]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfIntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfIntV(rv2i(rv).(map[interface{}]int), e)
 }
-func (_ fastpathT) EncMapIntfIntV(v map[interface{}]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntfIntV(v map[interface{}]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4359,43 +2563,40 @@ func (_ fastpathT) EncMapIntfIntV(v map[interface{}]int, checkNil bool, e *Encod
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfInt8R(rv reflect.Value) {
-	fastpathTV.EncMapIntfInt8V(rv2i(rv).(map[interface{}]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfInt8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfInt8V(rv2i(rv).(map[interface{}]int8), e)
 }
-func (_ fastpathT) EncMapIntfInt8V(v map[interface{}]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntfInt8V(v map[interface{}]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4412,43 +2613,40 @@ func (_ fastpathT) EncMapIntfInt8V(v map[interface{}]int8, checkNil bool, e *Enc
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfInt16R(rv reflect.Value) {
-	fastpathTV.EncMapIntfInt16V(rv2i(rv).(map[interface{}]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfInt16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfInt16V(rv2i(rv).(map[interface{}]int16), e)
 }
-func (_ fastpathT) EncMapIntfInt16V(v map[interface{}]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntfInt16V(v map[interface{}]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4465,43 +2663,40 @@ func (_ fastpathT) EncMapIntfInt16V(v map[interface{}]int16, checkNil bool, e *E
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfInt32R(rv reflect.Value) {
-	fastpathTV.EncMapIntfInt32V(rv2i(rv).(map[interface{}]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfInt32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfInt32V(rv2i(rv).(map[interface{}]int32), e)
 }
-func (_ fastpathT) EncMapIntfInt32V(v map[interface{}]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntfInt32V(v map[interface{}]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4518,43 +2713,40 @@ func (_ fastpathT) EncMapIntfInt32V(v map[interface{}]int32, checkNil bool, e *E
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfInt64R(rv reflect.Value) {
-	fastpathTV.EncMapIntfInt64V(rv2i(rv).(map[interface{}]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfInt64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfInt64V(rv2i(rv).(map[interface{}]int64), e)
 }
-func (_ fastpathT) EncMapIntfInt64V(v map[interface{}]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntfInt64V(v map[interface{}]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4571,43 +2763,40 @@ func (_ fastpathT) EncMapIntfInt64V(v map[interface{}]int64, checkNil bool, e *E
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfFloat32R(rv reflect.Value) {
-	fastpathTV.EncMapIntfFloat32V(rv2i(rv).(map[interface{}]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfFloat32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfFloat32V(rv2i(rv).(map[interface{}]float32), e)
 }
-func (_ fastpathT) EncMapIntfFloat32V(v map[interface{}]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntfFloat32V(v map[interface{}]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4624,43 +2813,40 @@ func (_ fastpathT) EncMapIntfFloat32V(v map[interface{}]float32, checkNil bool,
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfFloat64R(rv reflect.Value) {
-	fastpathTV.EncMapIntfFloat64V(rv2i(rv).(map[interface{}]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfFloat64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfFloat64V(rv2i(rv).(map[interface{}]float64), e)
 }
-func (_ fastpathT) EncMapIntfFloat64V(v map[interface{}]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntfFloat64V(v map[interface{}]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4677,43 +2863,40 @@ func (_ fastpathT) EncMapIntfFloat64V(v map[interface{}]float64, checkNil bool,
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntfBoolR(rv reflect.Value) {
-	fastpathTV.EncMapIntfBoolV(rv2i(rv).(map[interface{}]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntfBoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfBoolV(rv2i(rv).(map[interface{}]bool), e)
 }
-func (_ fastpathT) EncMapIntfBoolV(v map[interface{}]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntfBoolV(v map[interface{}]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -4730,43 +2913,40 @@ func (_ fastpathT) EncMapIntfBoolV(v map[interface{}]bool, checkNil bool, e *Enc
 		}
 		sort.Sort(bytesISlice(v2))
 		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[v2[j].i])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringIntfR(rv reflect.Value) {
-	fastpathTV.EncMapStringIntfV(rv2i(rv).(map[string]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringIntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringIntfV(rv2i(rv).(map[string]interface{}), e)
 }
-func (_ fastpathT) EncMapStringIntfV(v map[string]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapStringIntfV(v map[string]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -4777,51 +2957,48 @@ func (_ fastpathT) EncMapStringIntfV(v map[string]interface{}, checkNil bool, e
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[string(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringStringR(rv reflect.Value) {
-	fastpathTV.EncMapStringStringV(rv2i(rv).(map[string]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringStringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringStringV(rv2i(rv).(map[string]string), e)
 }
-func (_ fastpathT) EncMapStringStringV(v map[string]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapStringStringV(v map[string]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -4832,51 +3009,48 @@ func (_ fastpathT) EncMapStringStringV(v map[string]string, checkNil bool, e *En
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v[string(k2)])
+			ee.EncodeString(cUTF8, v[string(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v2)
+			ee.EncodeString(cUTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringUintR(rv reflect.Value) {
-	fastpathTV.EncMapStringUintV(rv2i(rv).(map[string]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringUintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringUintV(rv2i(rv).(map[string]uint), e)
 }
-func (_ fastpathT) EncMapStringUintV(v map[string]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapStringUintV(v map[string]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -4887,51 +3061,48 @@ func (_ fastpathT) EncMapStringUintV(v map[string]uint, checkNil bool, e *Encode
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[string(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringUint8R(rv reflect.Value) {
-	fastpathTV.EncMapStringUint8V(rv2i(rv).(map[string]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringUint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringUint8V(rv2i(rv).(map[string]uint8), e)
 }
-func (_ fastpathT) EncMapStringUint8V(v map[string]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapStringUint8V(v map[string]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -4942,51 +3113,48 @@ func (_ fastpathT) EncMapStringUint8V(v map[string]uint8, checkNil bool, e *Enco
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[string(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringUint16R(rv reflect.Value) {
-	fastpathTV.EncMapStringUint16V(rv2i(rv).(map[string]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringUint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringUint16V(rv2i(rv).(map[string]uint16), e)
 }
-func (_ fastpathT) EncMapStringUint16V(v map[string]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapStringUint16V(v map[string]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -4997,51 +3165,48 @@ func (_ fastpathT) EncMapStringUint16V(v map[string]uint16, checkNil bool, e *En
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[string(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringUint32R(rv reflect.Value) {
-	fastpathTV.EncMapStringUint32V(rv2i(rv).(map[string]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringUint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringUint32V(rv2i(rv).(map[string]uint32), e)
 }
-func (_ fastpathT) EncMapStringUint32V(v map[string]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapStringUint32V(v map[string]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -5052,51 +3217,48 @@ func (_ fastpathT) EncMapStringUint32V(v map[string]uint32, checkNil bool, e *En
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[string(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringUint64R(rv reflect.Value) {
-	fastpathTV.EncMapStringUint64V(rv2i(rv).(map[string]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringUint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringUint64V(rv2i(rv).(map[string]uint64), e)
 }
-func (_ fastpathT) EncMapStringUint64V(v map[string]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapStringUint64V(v map[string]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -5107,51 +3269,48 @@ func (_ fastpathT) EncMapStringUint64V(v map[string]uint64, checkNil bool, e *En
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[string(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringUintptrR(rv reflect.Value) {
-	fastpathTV.EncMapStringUintptrV(rv2i(rv).(map[string]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringUintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringUintptrV(rv2i(rv).(map[string]uintptr), e)
 }
-func (_ fastpathT) EncMapStringUintptrV(v map[string]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapStringUintptrV(v map[string]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -5162,51 +3321,48 @@ func (_ fastpathT) EncMapStringUintptrV(v map[string]uintptr, checkNil bool, e *
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[string(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringIntR(rv reflect.Value) {
-	fastpathTV.EncMapStringIntV(rv2i(rv).(map[string]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringIntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringIntV(rv2i(rv).(map[string]int), e)
 }
-func (_ fastpathT) EncMapStringIntV(v map[string]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapStringIntV(v map[string]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -5217,51 +3373,48 @@ func (_ fastpathT) EncMapStringIntV(v map[string]int, checkNil bool, e *Encoder)
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[string(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringInt8R(rv reflect.Value) {
-	fastpathTV.EncMapStringInt8V(rv2i(rv).(map[string]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringInt8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringInt8V(rv2i(rv).(map[string]int8), e)
 }
-func (_ fastpathT) EncMapStringInt8V(v map[string]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapStringInt8V(v map[string]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -5272,51 +3425,48 @@ func (_ fastpathT) EncMapStringInt8V(v map[string]int8, checkNil bool, e *Encode
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[string(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringInt16R(rv reflect.Value) {
-	fastpathTV.EncMapStringInt16V(rv2i(rv).(map[string]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringInt16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringInt16V(rv2i(rv).(map[string]int16), e)
 }
-func (_ fastpathT) EncMapStringInt16V(v map[string]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapStringInt16V(v map[string]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -5327,51 +3477,48 @@ func (_ fastpathT) EncMapStringInt16V(v map[string]int16, checkNil bool, e *Enco
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[string(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringInt32R(rv reflect.Value) {
-	fastpathTV.EncMapStringInt32V(rv2i(rv).(map[string]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringInt32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringInt32V(rv2i(rv).(map[string]int32), e)
 }
-func (_ fastpathT) EncMapStringInt32V(v map[string]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapStringInt32V(v map[string]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -5382,51 +3529,48 @@ func (_ fastpathT) EncMapStringInt32V(v map[string]int32, checkNil bool, e *Enco
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[string(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringInt64R(rv reflect.Value) {
-	fastpathTV.EncMapStringInt64V(rv2i(rv).(map[string]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringInt64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringInt64V(rv2i(rv).(map[string]int64), e)
 }
-func (_ fastpathT) EncMapStringInt64V(v map[string]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapStringInt64V(v map[string]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -5437,51 +3581,48 @@ func (_ fastpathT) EncMapStringInt64V(v map[string]int64, checkNil bool, e *Enco
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[string(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringFloat32R(rv reflect.Value) {
-	fastpathTV.EncMapStringFloat32V(rv2i(rv).(map[string]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringFloat32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringFloat32V(rv2i(rv).(map[string]float32), e)
 }
-func (_ fastpathT) EncMapStringFloat32V(v map[string]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapStringFloat32V(v map[string]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -5492,51 +3633,48 @@ func (_ fastpathT) EncMapStringFloat32V(v map[string]float32, checkNil bool, e *
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[string(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringFloat64R(rv reflect.Value) {
-	fastpathTV.EncMapStringFloat64V(rv2i(rv).(map[string]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringFloat64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringFloat64V(rv2i(rv).(map[string]float64), e)
 }
-func (_ fastpathT) EncMapStringFloat64V(v map[string]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapStringFloat64V(v map[string]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -5547,51 +3685,48 @@ func (_ fastpathT) EncMapStringFloat64V(v map[string]float64, checkNil bool, e *
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[string(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapStringBoolR(rv reflect.Value) {
-	fastpathTV.EncMapStringBoolV(rv2i(rv).(map[string]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapStringBoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapStringBoolV(rv2i(rv).(map[string]bool), e)
 }
-func (_ fastpathT) EncMapStringBoolV(v map[string]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapStringBoolV(v map[string]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
@@ -5602,51 +3737,48 @@ func (_ fastpathT) EncMapStringBoolV(v map[string]bool, checkNil bool, e *Encode
 		}
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[string(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			if asSymbols {
 				ee.EncodeSymbol(k2)
 			} else {
-				ee.EncodeString(c_UTF8, k2)
+				ee.EncodeString(cUTF8, k2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32IntfR(rv reflect.Value) {
-	fastpathTV.EncMapFloat32IntfV(rv2i(rv).(map[float32]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32IntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32IntfV(rv2i(rv).(map[float32]interface{}), e)
 }
-func (_ fastpathT) EncMapFloat32IntfV(v map[float32]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat32IntfV(v map[float32]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5656,43 +3788,40 @@ func (_ fastpathT) EncMapFloat32IntfV(v map[float32]interface{}, checkNil bool,
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[float32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32StringR(rv reflect.Value) {
-	fastpathTV.EncMapFloat32StringV(rv2i(rv).(map[float32]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32StringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32StringV(rv2i(rv).(map[float32]string), e)
 }
-func (_ fastpathT) EncMapFloat32StringV(v map[float32]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat32StringV(v map[float32]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5702,43 +3831,40 @@ func (_ fastpathT) EncMapFloat32StringV(v map[float32]string, checkNil bool, e *
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v[float32(k2)])
+			ee.EncodeString(cUTF8, v[float32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v2)
+			ee.EncodeString(cUTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32UintR(rv reflect.Value) {
-	fastpathTV.EncMapFloat32UintV(rv2i(rv).(map[float32]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32UintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32UintV(rv2i(rv).(map[float32]uint), e)
 }
-func (_ fastpathT) EncMapFloat32UintV(v map[float32]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat32UintV(v map[float32]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5748,43 +3874,40 @@ func (_ fastpathT) EncMapFloat32UintV(v map[float32]uint, checkNil bool, e *Enco
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[float32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32Uint8R(rv reflect.Value) {
-	fastpathTV.EncMapFloat32Uint8V(rv2i(rv).(map[float32]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32Uint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32Uint8V(rv2i(rv).(map[float32]uint8), e)
 }
-func (_ fastpathT) EncMapFloat32Uint8V(v map[float32]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat32Uint8V(v map[float32]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5794,43 +3917,40 @@ func (_ fastpathT) EncMapFloat32Uint8V(v map[float32]uint8, checkNil bool, e *En
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[float32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32Uint16R(rv reflect.Value) {
-	fastpathTV.EncMapFloat32Uint16V(rv2i(rv).(map[float32]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32Uint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32Uint16V(rv2i(rv).(map[float32]uint16), e)
 }
-func (_ fastpathT) EncMapFloat32Uint16V(v map[float32]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat32Uint16V(v map[float32]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5840,43 +3960,40 @@ func (_ fastpathT) EncMapFloat32Uint16V(v map[float32]uint16, checkNil bool, e *
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[float32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32Uint32R(rv reflect.Value) {
-	fastpathTV.EncMapFloat32Uint32V(rv2i(rv).(map[float32]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32Uint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32Uint32V(rv2i(rv).(map[float32]uint32), e)
 }
-func (_ fastpathT) EncMapFloat32Uint32V(v map[float32]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat32Uint32V(v map[float32]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5886,43 +4003,40 @@ func (_ fastpathT) EncMapFloat32Uint32V(v map[float32]uint32, checkNil bool, e *
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[float32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32Uint64R(rv reflect.Value) {
-	fastpathTV.EncMapFloat32Uint64V(rv2i(rv).(map[float32]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32Uint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32Uint64V(rv2i(rv).(map[float32]uint64), e)
 }
-func (_ fastpathT) EncMapFloat32Uint64V(v map[float32]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat32Uint64V(v map[float32]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5932,43 +4046,40 @@ func (_ fastpathT) EncMapFloat32Uint64V(v map[float32]uint64, checkNil bool, e *
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[float32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32UintptrR(rv reflect.Value) {
-	fastpathTV.EncMapFloat32UintptrV(rv2i(rv).(map[float32]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32UintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32UintptrV(rv2i(rv).(map[float32]uintptr), e)
 }
-func (_ fastpathT) EncMapFloat32UintptrV(v map[float32]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat32UintptrV(v map[float32]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5978,43 +4089,40 @@ func (_ fastpathT) EncMapFloat32UintptrV(v map[float32]uintptr, checkNil bool, e
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[float32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32IntR(rv reflect.Value) {
-	fastpathTV.EncMapFloat32IntV(rv2i(rv).(map[float32]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32IntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32IntV(rv2i(rv).(map[float32]int), e)
 }
-func (_ fastpathT) EncMapFloat32IntV(v map[float32]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat32IntV(v map[float32]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6024,43 +4132,40 @@ func (_ fastpathT) EncMapFloat32IntV(v map[float32]int, checkNil bool, e *Encode
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[float32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32Int8R(rv reflect.Value) {
-	fastpathTV.EncMapFloat32Int8V(rv2i(rv).(map[float32]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32Int8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32Int8V(rv2i(rv).(map[float32]int8), e)
 }
-func (_ fastpathT) EncMapFloat32Int8V(v map[float32]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat32Int8V(v map[float32]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6070,43 +4175,40 @@ func (_ fastpathT) EncMapFloat32Int8V(v map[float32]int8, checkNil bool, e *Enco
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[float32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32Int16R(rv reflect.Value) {
-	fastpathTV.EncMapFloat32Int16V(rv2i(rv).(map[float32]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32Int16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32Int16V(rv2i(rv).(map[float32]int16), e)
 }
-func (_ fastpathT) EncMapFloat32Int16V(v map[float32]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat32Int16V(v map[float32]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6116,43 +4218,40 @@ func (_ fastpathT) EncMapFloat32Int16V(v map[float32]int16, checkNil bool, e *En
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[float32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32Int32R(rv reflect.Value) {
-	fastpathTV.EncMapFloat32Int32V(rv2i(rv).(map[float32]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32Int32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32Int32V(rv2i(rv).(map[float32]int32), e)
 }
-func (_ fastpathT) EncMapFloat32Int32V(v map[float32]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat32Int32V(v map[float32]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6162,43 +4261,40 @@ func (_ fastpathT) EncMapFloat32Int32V(v map[float32]int32, checkNil bool, e *En
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[float32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32Int64R(rv reflect.Value) {
-	fastpathTV.EncMapFloat32Int64V(rv2i(rv).(map[float32]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32Int64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32Int64V(rv2i(rv).(map[float32]int64), e)
 }
-func (_ fastpathT) EncMapFloat32Int64V(v map[float32]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat32Int64V(v map[float32]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6208,43 +4304,40 @@ func (_ fastpathT) EncMapFloat32Int64V(v map[float32]int64, checkNil bool, e *En
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[float32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32Float32R(rv reflect.Value) {
-	fastpathTV.EncMapFloat32Float32V(rv2i(rv).(map[float32]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32Float32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32Float32V(rv2i(rv).(map[float32]float32), e)
 }
-func (_ fastpathT) EncMapFloat32Float32V(v map[float32]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat32Float32V(v map[float32]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6254,43 +4347,40 @@ func (_ fastpathT) EncMapFloat32Float32V(v map[float32]float32, checkNil bool, e
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[float32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32Float64R(rv reflect.Value) {
-	fastpathTV.EncMapFloat32Float64V(rv2i(rv).(map[float32]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32Float64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32Float64V(rv2i(rv).(map[float32]float64), e)
 }
-func (_ fastpathT) EncMapFloat32Float64V(v map[float32]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat32Float64V(v map[float32]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6300,43 +4390,40 @@ func (_ fastpathT) EncMapFloat32Float64V(v map[float32]float64, checkNil bool, e
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[float32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat32BoolR(rv reflect.Value) {
-	fastpathTV.EncMapFloat32BoolV(rv2i(rv).(map[float32]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat32BoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat32BoolV(rv2i(rv).(map[float32]bool), e)
 }
-func (_ fastpathT) EncMapFloat32BoolV(v map[float32]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat32BoolV(v map[float32]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6346,43 +4433,40 @@ func (_ fastpathT) EncMapFloat32BoolV(v map[float32]bool, checkNil bool, e *Enco
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[float32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64IntfR(rv reflect.Value) {
-	fastpathTV.EncMapFloat64IntfV(rv2i(rv).(map[float64]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64IntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64IntfV(rv2i(rv).(map[float64]interface{}), e)
 }
-func (_ fastpathT) EncMapFloat64IntfV(v map[float64]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat64IntfV(v map[float64]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6392,43 +4476,40 @@ func (_ fastpathT) EncMapFloat64IntfV(v map[float64]interface{}, checkNil bool,
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[float64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64StringR(rv reflect.Value) {
-	fastpathTV.EncMapFloat64StringV(rv2i(rv).(map[float64]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64StringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64StringV(rv2i(rv).(map[float64]string), e)
 }
-func (_ fastpathT) EncMapFloat64StringV(v map[float64]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat64StringV(v map[float64]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6438,43 +4519,40 @@ func (_ fastpathT) EncMapFloat64StringV(v map[float64]string, checkNil bool, e *
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v[float64(k2)])
+			ee.EncodeString(cUTF8, v[float64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v2)
+			ee.EncodeString(cUTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64UintR(rv reflect.Value) {
-	fastpathTV.EncMapFloat64UintV(rv2i(rv).(map[float64]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64UintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64UintV(rv2i(rv).(map[float64]uint), e)
 }
-func (_ fastpathT) EncMapFloat64UintV(v map[float64]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat64UintV(v map[float64]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6484,43 +4562,40 @@ func (_ fastpathT) EncMapFloat64UintV(v map[float64]uint, checkNil bool, e *Enco
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[float64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64Uint8R(rv reflect.Value) {
-	fastpathTV.EncMapFloat64Uint8V(rv2i(rv).(map[float64]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64Uint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64Uint8V(rv2i(rv).(map[float64]uint8), e)
 }
-func (_ fastpathT) EncMapFloat64Uint8V(v map[float64]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat64Uint8V(v map[float64]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6530,43 +4605,40 @@ func (_ fastpathT) EncMapFloat64Uint8V(v map[float64]uint8, checkNil bool, e *En
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[float64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64Uint16R(rv reflect.Value) {
-	fastpathTV.EncMapFloat64Uint16V(rv2i(rv).(map[float64]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64Uint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64Uint16V(rv2i(rv).(map[float64]uint16), e)
 }
-func (_ fastpathT) EncMapFloat64Uint16V(v map[float64]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat64Uint16V(v map[float64]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6576,43 +4648,40 @@ func (_ fastpathT) EncMapFloat64Uint16V(v map[float64]uint16, checkNil bool, e *
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[float64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64Uint32R(rv reflect.Value) {
-	fastpathTV.EncMapFloat64Uint32V(rv2i(rv).(map[float64]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64Uint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64Uint32V(rv2i(rv).(map[float64]uint32), e)
 }
-func (_ fastpathT) EncMapFloat64Uint32V(v map[float64]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat64Uint32V(v map[float64]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6622,43 +4691,40 @@ func (_ fastpathT) EncMapFloat64Uint32V(v map[float64]uint32, checkNil bool, e *
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[float64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64Uint64R(rv reflect.Value) {
-	fastpathTV.EncMapFloat64Uint64V(rv2i(rv).(map[float64]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64Uint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64Uint64V(rv2i(rv).(map[float64]uint64), e)
 }
-func (_ fastpathT) EncMapFloat64Uint64V(v map[float64]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat64Uint64V(v map[float64]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6668,43 +4734,40 @@ func (_ fastpathT) EncMapFloat64Uint64V(v map[float64]uint64, checkNil bool, e *
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[float64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64UintptrR(rv reflect.Value) {
-	fastpathTV.EncMapFloat64UintptrV(rv2i(rv).(map[float64]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64UintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64UintptrV(rv2i(rv).(map[float64]uintptr), e)
 }
-func (_ fastpathT) EncMapFloat64UintptrV(v map[float64]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat64UintptrV(v map[float64]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6714,43 +4777,40 @@ func (_ fastpathT) EncMapFloat64UintptrV(v map[float64]uintptr, checkNil bool, e
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[float64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64IntR(rv reflect.Value) {
-	fastpathTV.EncMapFloat64IntV(rv2i(rv).(map[float64]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64IntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64IntV(rv2i(rv).(map[float64]int), e)
 }
-func (_ fastpathT) EncMapFloat64IntV(v map[float64]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat64IntV(v map[float64]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6760,43 +4820,40 @@ func (_ fastpathT) EncMapFloat64IntV(v map[float64]int, checkNil bool, e *Encode
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[float64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64Int8R(rv reflect.Value) {
-	fastpathTV.EncMapFloat64Int8V(rv2i(rv).(map[float64]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64Int8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64Int8V(rv2i(rv).(map[float64]int8), e)
 }
-func (_ fastpathT) EncMapFloat64Int8V(v map[float64]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat64Int8V(v map[float64]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6806,43 +4863,40 @@ func (_ fastpathT) EncMapFloat64Int8V(v map[float64]int8, checkNil bool, e *Enco
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[float64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64Int16R(rv reflect.Value) {
-	fastpathTV.EncMapFloat64Int16V(rv2i(rv).(map[float64]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64Int16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64Int16V(rv2i(rv).(map[float64]int16), e)
 }
-func (_ fastpathT) EncMapFloat64Int16V(v map[float64]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat64Int16V(v map[float64]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6852,43 +4906,40 @@ func (_ fastpathT) EncMapFloat64Int16V(v map[float64]int16, checkNil bool, e *En
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[float64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64Int32R(rv reflect.Value) {
-	fastpathTV.EncMapFloat64Int32V(rv2i(rv).(map[float64]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64Int32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64Int32V(rv2i(rv).(map[float64]int32), e)
 }
-func (_ fastpathT) EncMapFloat64Int32V(v map[float64]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat64Int32V(v map[float64]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6898,43 +4949,40 @@ func (_ fastpathT) EncMapFloat64Int32V(v map[float64]int32, checkNil bool, e *En
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[float64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64Int64R(rv reflect.Value) {
-	fastpathTV.EncMapFloat64Int64V(rv2i(rv).(map[float64]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64Int64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64Int64V(rv2i(rv).(map[float64]int64), e)
 }
-func (_ fastpathT) EncMapFloat64Int64V(v map[float64]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat64Int64V(v map[float64]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6944,43 +4992,40 @@ func (_ fastpathT) EncMapFloat64Int64V(v map[float64]int64, checkNil bool, e *En
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[float64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64Float32R(rv reflect.Value) {
-	fastpathTV.EncMapFloat64Float32V(rv2i(rv).(map[float64]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64Float32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64Float32V(rv2i(rv).(map[float64]float32), e)
 }
-func (_ fastpathT) EncMapFloat64Float32V(v map[float64]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat64Float32V(v map[float64]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6990,43 +5035,40 @@ func (_ fastpathT) EncMapFloat64Float32V(v map[float64]float32, checkNil bool, e
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[float64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64Float64R(rv reflect.Value) {
-	fastpathTV.EncMapFloat64Float64V(rv2i(rv).(map[float64]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64Float64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64Float64V(rv2i(rv).(map[float64]float64), e)
 }
-func (_ fastpathT) EncMapFloat64Float64V(v map[float64]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat64Float64V(v map[float64]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -7036,43 +5078,40 @@ func (_ fastpathT) EncMapFloat64Float64V(v map[float64]float64, checkNil bool, e
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[float64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapFloat64BoolR(rv reflect.Value) {
-	fastpathTV.EncMapFloat64BoolV(rv2i(rv).(map[float64]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapFloat64BoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapFloat64BoolV(rv2i(rv).(map[float64]bool), e)
 }
-func (_ fastpathT) EncMapFloat64BoolV(v map[float64]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapFloat64BoolV(v map[float64]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -7082,43 +5121,40 @@ func (_ fastpathT) EncMapFloat64BoolV(v map[float64]bool, checkNil bool, e *Enco
 		}
 		sort.Sort(floatSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[float64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintIntfR(rv reflect.Value) {
-	fastpathTV.EncMapUintIntfV(rv2i(rv).(map[uint]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintIntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintIntfV(rv2i(rv).(map[uint]interface{}), e)
 }
-func (_ fastpathT) EncMapUintIntfV(v map[uint]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintIntfV(v map[uint]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7128,43 +5164,40 @@ func (_ fastpathT) EncMapUintIntfV(v map[uint]interface{}, checkNil bool, e *Enc
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uint(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintStringR(rv reflect.Value) {
-	fastpathTV.EncMapUintStringV(rv2i(rv).(map[uint]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintStringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintStringV(rv2i(rv).(map[uint]string), e)
 }
-func (_ fastpathT) EncMapUintStringV(v map[uint]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintStringV(v map[uint]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7174,43 +5207,40 @@ func (_ fastpathT) EncMapUintStringV(v map[uint]string, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v[uint(k2)])
+			ee.EncodeString(cUTF8, v[uint(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v2)
+			ee.EncodeString(cUTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintUintR(rv reflect.Value) {
-	fastpathTV.EncMapUintUintV(rv2i(rv).(map[uint]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintUintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintUintV(rv2i(rv).(map[uint]uint), e)
 }
-func (_ fastpathT) EncMapUintUintV(v map[uint]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintUintV(v map[uint]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7220,43 +5250,40 @@ func (_ fastpathT) EncMapUintUintV(v map[uint]uint, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintUint8R(rv reflect.Value) {
-	fastpathTV.EncMapUintUint8V(rv2i(rv).(map[uint]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintUint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintUint8V(rv2i(rv).(map[uint]uint8), e)
 }
-func (_ fastpathT) EncMapUintUint8V(v map[uint]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintUint8V(v map[uint]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7266,43 +5293,40 @@ func (_ fastpathT) EncMapUintUint8V(v map[uint]uint8, checkNil bool, e *Encoder)
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintUint16R(rv reflect.Value) {
-	fastpathTV.EncMapUintUint16V(rv2i(rv).(map[uint]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintUint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintUint16V(rv2i(rv).(map[uint]uint16), e)
 }
-func (_ fastpathT) EncMapUintUint16V(v map[uint]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintUint16V(v map[uint]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7312,43 +5336,40 @@ func (_ fastpathT) EncMapUintUint16V(v map[uint]uint16, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintUint32R(rv reflect.Value) {
-	fastpathTV.EncMapUintUint32V(rv2i(rv).(map[uint]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintUint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintUint32V(rv2i(rv).(map[uint]uint32), e)
 }
-func (_ fastpathT) EncMapUintUint32V(v map[uint]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintUint32V(v map[uint]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7358,43 +5379,40 @@ func (_ fastpathT) EncMapUintUint32V(v map[uint]uint32, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintUint64R(rv reflect.Value) {
-	fastpathTV.EncMapUintUint64V(rv2i(rv).(map[uint]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintUint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintUint64V(rv2i(rv).(map[uint]uint64), e)
 }
-func (_ fastpathT) EncMapUintUint64V(v map[uint]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintUint64V(v map[uint]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7404,43 +5422,40 @@ func (_ fastpathT) EncMapUintUint64V(v map[uint]uint64, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintUintptrR(rv reflect.Value) {
-	fastpathTV.EncMapUintUintptrV(rv2i(rv).(map[uint]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintUintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintUintptrV(rv2i(rv).(map[uint]uintptr), e)
 }
-func (_ fastpathT) EncMapUintUintptrV(v map[uint]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintUintptrV(v map[uint]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7450,43 +5465,40 @@ func (_ fastpathT) EncMapUintUintptrV(v map[uint]uintptr, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uint(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintIntR(rv reflect.Value) {
-	fastpathTV.EncMapUintIntV(rv2i(rv).(map[uint]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintIntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintIntV(rv2i(rv).(map[uint]int), e)
 }
-func (_ fastpathT) EncMapUintIntV(v map[uint]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintIntV(v map[uint]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7496,43 +5508,40 @@ func (_ fastpathT) EncMapUintIntV(v map[uint]int, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintInt8R(rv reflect.Value) {
-	fastpathTV.EncMapUintInt8V(rv2i(rv).(map[uint]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintInt8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintInt8V(rv2i(rv).(map[uint]int8), e)
 }
-func (_ fastpathT) EncMapUintInt8V(v map[uint]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintInt8V(v map[uint]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7542,43 +5551,40 @@ func (_ fastpathT) EncMapUintInt8V(v map[uint]int8, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintInt16R(rv reflect.Value) {
-	fastpathTV.EncMapUintInt16V(rv2i(rv).(map[uint]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintInt16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintInt16V(rv2i(rv).(map[uint]int16), e)
 }
-func (_ fastpathT) EncMapUintInt16V(v map[uint]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintInt16V(v map[uint]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7588,43 +5594,40 @@ func (_ fastpathT) EncMapUintInt16V(v map[uint]int16, checkNil bool, e *Encoder)
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintInt32R(rv reflect.Value) {
-	fastpathTV.EncMapUintInt32V(rv2i(rv).(map[uint]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintInt32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintInt32V(rv2i(rv).(map[uint]int32), e)
 }
-func (_ fastpathT) EncMapUintInt32V(v map[uint]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintInt32V(v map[uint]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7634,43 +5637,40 @@ func (_ fastpathT) EncMapUintInt32V(v map[uint]int32, checkNil bool, e *Encoder)
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintInt64R(rv reflect.Value) {
-	fastpathTV.EncMapUintInt64V(rv2i(rv).(map[uint]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintInt64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintInt64V(rv2i(rv).(map[uint]int64), e)
 }
-func (_ fastpathT) EncMapUintInt64V(v map[uint]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintInt64V(v map[uint]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7680,43 +5680,40 @@ func (_ fastpathT) EncMapUintInt64V(v map[uint]int64, checkNil bool, e *Encoder)
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintFloat32R(rv reflect.Value) {
-	fastpathTV.EncMapUintFloat32V(rv2i(rv).(map[uint]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintFloat32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintFloat32V(rv2i(rv).(map[uint]float32), e)
 }
-func (_ fastpathT) EncMapUintFloat32V(v map[uint]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintFloat32V(v map[uint]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7726,43 +5723,40 @@ func (_ fastpathT) EncMapUintFloat32V(v map[uint]float32, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[uint(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintFloat64R(rv reflect.Value) {
-	fastpathTV.EncMapUintFloat64V(rv2i(rv).(map[uint]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintFloat64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintFloat64V(rv2i(rv).(map[uint]float64), e)
 }
-func (_ fastpathT) EncMapUintFloat64V(v map[uint]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintFloat64V(v map[uint]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7772,43 +5766,40 @@ func (_ fastpathT) EncMapUintFloat64V(v map[uint]float64, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[uint(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintBoolR(rv reflect.Value) {
-	fastpathTV.EncMapUintBoolV(rv2i(rv).(map[uint]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintBoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintBoolV(rv2i(rv).(map[uint]bool), e)
 }
-func (_ fastpathT) EncMapUintBoolV(v map[uint]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintBoolV(v map[uint]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7818,43 +5809,40 @@ func (_ fastpathT) EncMapUintBoolV(v map[uint]bool, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[uint(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8IntfR(rv reflect.Value) {
-	fastpathTV.EncMapUint8IntfV(rv2i(rv).(map[uint8]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8IntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8IntfV(rv2i(rv).(map[uint8]interface{}), e)
 }
-func (_ fastpathT) EncMapUint8IntfV(v map[uint8]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint8IntfV(v map[uint8]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7864,43 +5852,40 @@ func (_ fastpathT) EncMapUint8IntfV(v map[uint8]interface{}, checkNil bool, e *E
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uint8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8StringR(rv reflect.Value) {
-	fastpathTV.EncMapUint8StringV(rv2i(rv).(map[uint8]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8StringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8StringV(rv2i(rv).(map[uint8]string), e)
 }
-func (_ fastpathT) EncMapUint8StringV(v map[uint8]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint8StringV(v map[uint8]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7910,43 +5895,40 @@ func (_ fastpathT) EncMapUint8StringV(v map[uint8]string, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v[uint8(k2)])
+			ee.EncodeString(cUTF8, v[uint8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v2)
+			ee.EncodeString(cUTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8UintR(rv reflect.Value) {
-	fastpathTV.EncMapUint8UintV(rv2i(rv).(map[uint8]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8UintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8UintV(rv2i(rv).(map[uint8]uint), e)
 }
-func (_ fastpathT) EncMapUint8UintV(v map[uint8]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint8UintV(v map[uint8]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7956,43 +5938,40 @@ func (_ fastpathT) EncMapUint8UintV(v map[uint8]uint, checkNil bool, e *Encoder)
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8Uint8R(rv reflect.Value) {
-	fastpathTV.EncMapUint8Uint8V(rv2i(rv).(map[uint8]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8Uint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8Uint8V(rv2i(rv).(map[uint8]uint8), e)
 }
-func (_ fastpathT) EncMapUint8Uint8V(v map[uint8]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint8Uint8V(v map[uint8]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8002,43 +5981,40 @@ func (_ fastpathT) EncMapUint8Uint8V(v map[uint8]uint8, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8Uint16R(rv reflect.Value) {
-	fastpathTV.EncMapUint8Uint16V(rv2i(rv).(map[uint8]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8Uint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8Uint16V(rv2i(rv).(map[uint8]uint16), e)
 }
-func (_ fastpathT) EncMapUint8Uint16V(v map[uint8]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint8Uint16V(v map[uint8]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8048,43 +6024,40 @@ func (_ fastpathT) EncMapUint8Uint16V(v map[uint8]uint16, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8Uint32R(rv reflect.Value) {
-	fastpathTV.EncMapUint8Uint32V(rv2i(rv).(map[uint8]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8Uint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8Uint32V(rv2i(rv).(map[uint8]uint32), e)
 }
-func (_ fastpathT) EncMapUint8Uint32V(v map[uint8]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint8Uint32V(v map[uint8]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8094,43 +6067,40 @@ func (_ fastpathT) EncMapUint8Uint32V(v map[uint8]uint32, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8Uint64R(rv reflect.Value) {
-	fastpathTV.EncMapUint8Uint64V(rv2i(rv).(map[uint8]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8Uint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8Uint64V(rv2i(rv).(map[uint8]uint64), e)
 }
-func (_ fastpathT) EncMapUint8Uint64V(v map[uint8]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint8Uint64V(v map[uint8]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8140,43 +6110,40 @@ func (_ fastpathT) EncMapUint8Uint64V(v map[uint8]uint64, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8UintptrR(rv reflect.Value) {
-	fastpathTV.EncMapUint8UintptrV(rv2i(rv).(map[uint8]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8UintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8UintptrV(rv2i(rv).(map[uint8]uintptr), e)
 }
-func (_ fastpathT) EncMapUint8UintptrV(v map[uint8]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint8UintptrV(v map[uint8]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8186,43 +6153,40 @@ func (_ fastpathT) EncMapUint8UintptrV(v map[uint8]uintptr, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uint8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8IntR(rv reflect.Value) {
-	fastpathTV.EncMapUint8IntV(rv2i(rv).(map[uint8]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8IntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8IntV(rv2i(rv).(map[uint8]int), e)
 }
-func (_ fastpathT) EncMapUint8IntV(v map[uint8]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint8IntV(v map[uint8]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8232,43 +6196,40 @@ func (_ fastpathT) EncMapUint8IntV(v map[uint8]int, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8Int8R(rv reflect.Value) {
-	fastpathTV.EncMapUint8Int8V(rv2i(rv).(map[uint8]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8Int8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8Int8V(rv2i(rv).(map[uint8]int8), e)
 }
-func (_ fastpathT) EncMapUint8Int8V(v map[uint8]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint8Int8V(v map[uint8]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8278,43 +6239,40 @@ func (_ fastpathT) EncMapUint8Int8V(v map[uint8]int8, checkNil bool, e *Encoder)
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8Int16R(rv reflect.Value) {
-	fastpathTV.EncMapUint8Int16V(rv2i(rv).(map[uint8]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8Int16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8Int16V(rv2i(rv).(map[uint8]int16), e)
 }
-func (_ fastpathT) EncMapUint8Int16V(v map[uint8]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint8Int16V(v map[uint8]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8324,43 +6282,40 @@ func (_ fastpathT) EncMapUint8Int16V(v map[uint8]int16, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8Int32R(rv reflect.Value) {
-	fastpathTV.EncMapUint8Int32V(rv2i(rv).(map[uint8]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8Int32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8Int32V(rv2i(rv).(map[uint8]int32), e)
 }
-func (_ fastpathT) EncMapUint8Int32V(v map[uint8]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint8Int32V(v map[uint8]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8370,43 +6325,40 @@ func (_ fastpathT) EncMapUint8Int32V(v map[uint8]int32, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8Int64R(rv reflect.Value) {
-	fastpathTV.EncMapUint8Int64V(rv2i(rv).(map[uint8]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8Int64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8Int64V(rv2i(rv).(map[uint8]int64), e)
 }
-func (_ fastpathT) EncMapUint8Int64V(v map[uint8]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint8Int64V(v map[uint8]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8416,43 +6368,40 @@ func (_ fastpathT) EncMapUint8Int64V(v map[uint8]int64, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8Float32R(rv reflect.Value) {
-	fastpathTV.EncMapUint8Float32V(rv2i(rv).(map[uint8]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8Float32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8Float32V(rv2i(rv).(map[uint8]float32), e)
 }
-func (_ fastpathT) EncMapUint8Float32V(v map[uint8]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint8Float32V(v map[uint8]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8462,43 +6411,40 @@ func (_ fastpathT) EncMapUint8Float32V(v map[uint8]float32, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[uint8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8Float64R(rv reflect.Value) {
-	fastpathTV.EncMapUint8Float64V(rv2i(rv).(map[uint8]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8Float64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8Float64V(rv2i(rv).(map[uint8]float64), e)
 }
-func (_ fastpathT) EncMapUint8Float64V(v map[uint8]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint8Float64V(v map[uint8]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8508,43 +6454,40 @@ func (_ fastpathT) EncMapUint8Float64V(v map[uint8]float64, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[uint8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint8BoolR(rv reflect.Value) {
-	fastpathTV.EncMapUint8BoolV(rv2i(rv).(map[uint8]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint8BoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint8BoolV(rv2i(rv).(map[uint8]bool), e)
 }
-func (_ fastpathT) EncMapUint8BoolV(v map[uint8]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint8BoolV(v map[uint8]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8554,43 +6497,40 @@ func (_ fastpathT) EncMapUint8BoolV(v map[uint8]bool, checkNil bool, e *Encoder)
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[uint8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16IntfR(rv reflect.Value) {
-	fastpathTV.EncMapUint16IntfV(rv2i(rv).(map[uint16]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16IntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16IntfV(rv2i(rv).(map[uint16]interface{}), e)
 }
-func (_ fastpathT) EncMapUint16IntfV(v map[uint16]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint16IntfV(v map[uint16]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8600,43 +6540,40 @@ func (_ fastpathT) EncMapUint16IntfV(v map[uint16]interface{}, checkNil bool, e
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uint16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16StringR(rv reflect.Value) {
-	fastpathTV.EncMapUint16StringV(rv2i(rv).(map[uint16]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16StringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16StringV(rv2i(rv).(map[uint16]string), e)
 }
-func (_ fastpathT) EncMapUint16StringV(v map[uint16]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint16StringV(v map[uint16]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8646,43 +6583,40 @@ func (_ fastpathT) EncMapUint16StringV(v map[uint16]string, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v[uint16(k2)])
+			ee.EncodeString(cUTF8, v[uint16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v2)
+			ee.EncodeString(cUTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16UintR(rv reflect.Value) {
-	fastpathTV.EncMapUint16UintV(rv2i(rv).(map[uint16]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16UintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16UintV(rv2i(rv).(map[uint16]uint), e)
 }
-func (_ fastpathT) EncMapUint16UintV(v map[uint16]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint16UintV(v map[uint16]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8692,43 +6626,40 @@ func (_ fastpathT) EncMapUint16UintV(v map[uint16]uint, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16Uint8R(rv reflect.Value) {
-	fastpathTV.EncMapUint16Uint8V(rv2i(rv).(map[uint16]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16Uint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16Uint8V(rv2i(rv).(map[uint16]uint8), e)
 }
-func (_ fastpathT) EncMapUint16Uint8V(v map[uint16]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint16Uint8V(v map[uint16]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8738,43 +6669,40 @@ func (_ fastpathT) EncMapUint16Uint8V(v map[uint16]uint8, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16Uint16R(rv reflect.Value) {
-	fastpathTV.EncMapUint16Uint16V(rv2i(rv).(map[uint16]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16Uint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16Uint16V(rv2i(rv).(map[uint16]uint16), e)
 }
-func (_ fastpathT) EncMapUint16Uint16V(v map[uint16]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint16Uint16V(v map[uint16]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8784,43 +6712,40 @@ func (_ fastpathT) EncMapUint16Uint16V(v map[uint16]uint16, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16Uint32R(rv reflect.Value) {
-	fastpathTV.EncMapUint16Uint32V(rv2i(rv).(map[uint16]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16Uint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16Uint32V(rv2i(rv).(map[uint16]uint32), e)
 }
-func (_ fastpathT) EncMapUint16Uint32V(v map[uint16]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint16Uint32V(v map[uint16]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8830,43 +6755,40 @@ func (_ fastpathT) EncMapUint16Uint32V(v map[uint16]uint32, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16Uint64R(rv reflect.Value) {
-	fastpathTV.EncMapUint16Uint64V(rv2i(rv).(map[uint16]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16Uint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16Uint64V(rv2i(rv).(map[uint16]uint64), e)
 }
-func (_ fastpathT) EncMapUint16Uint64V(v map[uint16]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint16Uint64V(v map[uint16]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8876,43 +6798,40 @@ func (_ fastpathT) EncMapUint16Uint64V(v map[uint16]uint64, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16UintptrR(rv reflect.Value) {
-	fastpathTV.EncMapUint16UintptrV(rv2i(rv).(map[uint16]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16UintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16UintptrV(rv2i(rv).(map[uint16]uintptr), e)
 }
-func (_ fastpathT) EncMapUint16UintptrV(v map[uint16]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint16UintptrV(v map[uint16]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8922,43 +6841,40 @@ func (_ fastpathT) EncMapUint16UintptrV(v map[uint16]uintptr, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uint16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16IntR(rv reflect.Value) {
-	fastpathTV.EncMapUint16IntV(rv2i(rv).(map[uint16]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16IntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16IntV(rv2i(rv).(map[uint16]int), e)
 }
-func (_ fastpathT) EncMapUint16IntV(v map[uint16]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint16IntV(v map[uint16]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8968,43 +6884,40 @@ func (_ fastpathT) EncMapUint16IntV(v map[uint16]int, checkNil bool, e *Encoder)
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16Int8R(rv reflect.Value) {
-	fastpathTV.EncMapUint16Int8V(rv2i(rv).(map[uint16]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16Int8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16Int8V(rv2i(rv).(map[uint16]int8), e)
 }
-func (_ fastpathT) EncMapUint16Int8V(v map[uint16]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint16Int8V(v map[uint16]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9014,43 +6927,40 @@ func (_ fastpathT) EncMapUint16Int8V(v map[uint16]int8, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16Int16R(rv reflect.Value) {
-	fastpathTV.EncMapUint16Int16V(rv2i(rv).(map[uint16]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16Int16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16Int16V(rv2i(rv).(map[uint16]int16), e)
 }
-func (_ fastpathT) EncMapUint16Int16V(v map[uint16]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint16Int16V(v map[uint16]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9060,43 +6970,40 @@ func (_ fastpathT) EncMapUint16Int16V(v map[uint16]int16, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16Int32R(rv reflect.Value) {
-	fastpathTV.EncMapUint16Int32V(rv2i(rv).(map[uint16]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16Int32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16Int32V(rv2i(rv).(map[uint16]int32), e)
 }
-func (_ fastpathT) EncMapUint16Int32V(v map[uint16]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint16Int32V(v map[uint16]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9106,43 +7013,40 @@ func (_ fastpathT) EncMapUint16Int32V(v map[uint16]int32, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16Int64R(rv reflect.Value) {
-	fastpathTV.EncMapUint16Int64V(rv2i(rv).(map[uint16]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16Int64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16Int64V(rv2i(rv).(map[uint16]int64), e)
 }
-func (_ fastpathT) EncMapUint16Int64V(v map[uint16]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint16Int64V(v map[uint16]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9152,43 +7056,40 @@ func (_ fastpathT) EncMapUint16Int64V(v map[uint16]int64, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16Float32R(rv reflect.Value) {
-	fastpathTV.EncMapUint16Float32V(rv2i(rv).(map[uint16]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16Float32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16Float32V(rv2i(rv).(map[uint16]float32), e)
 }
-func (_ fastpathT) EncMapUint16Float32V(v map[uint16]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint16Float32V(v map[uint16]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9198,43 +7099,40 @@ func (_ fastpathT) EncMapUint16Float32V(v map[uint16]float32, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[uint16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16Float64R(rv reflect.Value) {
-	fastpathTV.EncMapUint16Float64V(rv2i(rv).(map[uint16]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16Float64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16Float64V(rv2i(rv).(map[uint16]float64), e)
 }
-func (_ fastpathT) EncMapUint16Float64V(v map[uint16]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint16Float64V(v map[uint16]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9244,43 +7142,40 @@ func (_ fastpathT) EncMapUint16Float64V(v map[uint16]float64, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[uint16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint16BoolR(rv reflect.Value) {
-	fastpathTV.EncMapUint16BoolV(rv2i(rv).(map[uint16]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint16BoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint16BoolV(rv2i(rv).(map[uint16]bool), e)
 }
-func (_ fastpathT) EncMapUint16BoolV(v map[uint16]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint16BoolV(v map[uint16]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9290,43 +7185,40 @@ func (_ fastpathT) EncMapUint16BoolV(v map[uint16]bool, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[uint16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32IntfR(rv reflect.Value) {
-	fastpathTV.EncMapUint32IntfV(rv2i(rv).(map[uint32]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32IntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32IntfV(rv2i(rv).(map[uint32]interface{}), e)
 }
-func (_ fastpathT) EncMapUint32IntfV(v map[uint32]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint32IntfV(v map[uint32]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9336,43 +7228,40 @@ func (_ fastpathT) EncMapUint32IntfV(v map[uint32]interface{}, checkNil bool, e
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uint32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32StringR(rv reflect.Value) {
-	fastpathTV.EncMapUint32StringV(rv2i(rv).(map[uint32]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32StringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32StringV(rv2i(rv).(map[uint32]string), e)
 }
-func (_ fastpathT) EncMapUint32StringV(v map[uint32]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint32StringV(v map[uint32]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9382,43 +7271,40 @@ func (_ fastpathT) EncMapUint32StringV(v map[uint32]string, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v[uint32(k2)])
+			ee.EncodeString(cUTF8, v[uint32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v2)
+			ee.EncodeString(cUTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32UintR(rv reflect.Value) {
-	fastpathTV.EncMapUint32UintV(rv2i(rv).(map[uint32]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32UintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32UintV(rv2i(rv).(map[uint32]uint), e)
 }
-func (_ fastpathT) EncMapUint32UintV(v map[uint32]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint32UintV(v map[uint32]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9428,43 +7314,40 @@ func (_ fastpathT) EncMapUint32UintV(v map[uint32]uint, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32Uint8R(rv reflect.Value) {
-	fastpathTV.EncMapUint32Uint8V(rv2i(rv).(map[uint32]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32Uint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32Uint8V(rv2i(rv).(map[uint32]uint8), e)
 }
-func (_ fastpathT) EncMapUint32Uint8V(v map[uint32]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint32Uint8V(v map[uint32]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9474,43 +7357,40 @@ func (_ fastpathT) EncMapUint32Uint8V(v map[uint32]uint8, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32Uint16R(rv reflect.Value) {
-	fastpathTV.EncMapUint32Uint16V(rv2i(rv).(map[uint32]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32Uint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32Uint16V(rv2i(rv).(map[uint32]uint16), e)
 }
-func (_ fastpathT) EncMapUint32Uint16V(v map[uint32]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint32Uint16V(v map[uint32]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9520,43 +7400,40 @@ func (_ fastpathT) EncMapUint32Uint16V(v map[uint32]uint16, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32Uint32R(rv reflect.Value) {
-	fastpathTV.EncMapUint32Uint32V(rv2i(rv).(map[uint32]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32Uint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32Uint32V(rv2i(rv).(map[uint32]uint32), e)
 }
-func (_ fastpathT) EncMapUint32Uint32V(v map[uint32]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint32Uint32V(v map[uint32]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9566,43 +7443,40 @@ func (_ fastpathT) EncMapUint32Uint32V(v map[uint32]uint32, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32Uint64R(rv reflect.Value) {
-	fastpathTV.EncMapUint32Uint64V(rv2i(rv).(map[uint32]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32Uint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32Uint64V(rv2i(rv).(map[uint32]uint64), e)
 }
-func (_ fastpathT) EncMapUint32Uint64V(v map[uint32]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint32Uint64V(v map[uint32]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9612,43 +7486,40 @@ func (_ fastpathT) EncMapUint32Uint64V(v map[uint32]uint64, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32UintptrR(rv reflect.Value) {
-	fastpathTV.EncMapUint32UintptrV(rv2i(rv).(map[uint32]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32UintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32UintptrV(rv2i(rv).(map[uint32]uintptr), e)
 }
-func (_ fastpathT) EncMapUint32UintptrV(v map[uint32]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint32UintptrV(v map[uint32]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9658,43 +7529,40 @@ func (_ fastpathT) EncMapUint32UintptrV(v map[uint32]uintptr, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uint32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32IntR(rv reflect.Value) {
-	fastpathTV.EncMapUint32IntV(rv2i(rv).(map[uint32]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32IntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32IntV(rv2i(rv).(map[uint32]int), e)
 }
-func (_ fastpathT) EncMapUint32IntV(v map[uint32]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint32IntV(v map[uint32]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9704,43 +7572,40 @@ func (_ fastpathT) EncMapUint32IntV(v map[uint32]int, checkNil bool, e *Encoder)
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32Int8R(rv reflect.Value) {
-	fastpathTV.EncMapUint32Int8V(rv2i(rv).(map[uint32]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32Int8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32Int8V(rv2i(rv).(map[uint32]int8), e)
 }
-func (_ fastpathT) EncMapUint32Int8V(v map[uint32]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint32Int8V(v map[uint32]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9750,43 +7615,40 @@ func (_ fastpathT) EncMapUint32Int8V(v map[uint32]int8, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32Int16R(rv reflect.Value) {
-	fastpathTV.EncMapUint32Int16V(rv2i(rv).(map[uint32]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32Int16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32Int16V(rv2i(rv).(map[uint32]int16), e)
 }
-func (_ fastpathT) EncMapUint32Int16V(v map[uint32]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint32Int16V(v map[uint32]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9796,43 +7658,40 @@ func (_ fastpathT) EncMapUint32Int16V(v map[uint32]int16, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32Int32R(rv reflect.Value) {
-	fastpathTV.EncMapUint32Int32V(rv2i(rv).(map[uint32]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32Int32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32Int32V(rv2i(rv).(map[uint32]int32), e)
 }
-func (_ fastpathT) EncMapUint32Int32V(v map[uint32]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint32Int32V(v map[uint32]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9842,43 +7701,40 @@ func (_ fastpathT) EncMapUint32Int32V(v map[uint32]int32, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32Int64R(rv reflect.Value) {
-	fastpathTV.EncMapUint32Int64V(rv2i(rv).(map[uint32]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32Int64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32Int64V(rv2i(rv).(map[uint32]int64), e)
 }
-func (_ fastpathT) EncMapUint32Int64V(v map[uint32]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint32Int64V(v map[uint32]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9888,43 +7744,40 @@ func (_ fastpathT) EncMapUint32Int64V(v map[uint32]int64, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32Float32R(rv reflect.Value) {
-	fastpathTV.EncMapUint32Float32V(rv2i(rv).(map[uint32]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32Float32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32Float32V(rv2i(rv).(map[uint32]float32), e)
 }
-func (_ fastpathT) EncMapUint32Float32V(v map[uint32]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint32Float32V(v map[uint32]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9934,43 +7787,40 @@ func (_ fastpathT) EncMapUint32Float32V(v map[uint32]float32, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[uint32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32Float64R(rv reflect.Value) {
-	fastpathTV.EncMapUint32Float64V(rv2i(rv).(map[uint32]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32Float64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32Float64V(rv2i(rv).(map[uint32]float64), e)
 }
-func (_ fastpathT) EncMapUint32Float64V(v map[uint32]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint32Float64V(v map[uint32]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9980,43 +7830,40 @@ func (_ fastpathT) EncMapUint32Float64V(v map[uint32]float64, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[uint32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint32BoolR(rv reflect.Value) {
-	fastpathTV.EncMapUint32BoolV(rv2i(rv).(map[uint32]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint32BoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint32BoolV(rv2i(rv).(map[uint32]bool), e)
 }
-func (_ fastpathT) EncMapUint32BoolV(v map[uint32]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint32BoolV(v map[uint32]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10026,43 +7873,40 @@ func (_ fastpathT) EncMapUint32BoolV(v map[uint32]bool, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[uint32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64IntfR(rv reflect.Value) {
-	fastpathTV.EncMapUint64IntfV(rv2i(rv).(map[uint64]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64IntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64IntfV(rv2i(rv).(map[uint64]interface{}), e)
 }
-func (_ fastpathT) EncMapUint64IntfV(v map[uint64]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint64IntfV(v map[uint64]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10072,43 +7916,40 @@ func (_ fastpathT) EncMapUint64IntfV(v map[uint64]interface{}, checkNil bool, e
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uint64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64StringR(rv reflect.Value) {
-	fastpathTV.EncMapUint64StringV(rv2i(rv).(map[uint64]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64StringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64StringV(rv2i(rv).(map[uint64]string), e)
 }
-func (_ fastpathT) EncMapUint64StringV(v map[uint64]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint64StringV(v map[uint64]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10118,43 +7959,40 @@ func (_ fastpathT) EncMapUint64StringV(v map[uint64]string, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v[uint64(k2)])
+			ee.EncodeString(cUTF8, v[uint64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v2)
+			ee.EncodeString(cUTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64UintR(rv reflect.Value) {
-	fastpathTV.EncMapUint64UintV(rv2i(rv).(map[uint64]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64UintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64UintV(rv2i(rv).(map[uint64]uint), e)
 }
-func (_ fastpathT) EncMapUint64UintV(v map[uint64]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint64UintV(v map[uint64]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10164,43 +8002,40 @@ func (_ fastpathT) EncMapUint64UintV(v map[uint64]uint, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64Uint8R(rv reflect.Value) {
-	fastpathTV.EncMapUint64Uint8V(rv2i(rv).(map[uint64]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64Uint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64Uint8V(rv2i(rv).(map[uint64]uint8), e)
 }
-func (_ fastpathT) EncMapUint64Uint8V(v map[uint64]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint64Uint8V(v map[uint64]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10210,43 +8045,40 @@ func (_ fastpathT) EncMapUint64Uint8V(v map[uint64]uint8, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64Uint16R(rv reflect.Value) {
-	fastpathTV.EncMapUint64Uint16V(rv2i(rv).(map[uint64]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64Uint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64Uint16V(rv2i(rv).(map[uint64]uint16), e)
 }
-func (_ fastpathT) EncMapUint64Uint16V(v map[uint64]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint64Uint16V(v map[uint64]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10256,43 +8088,40 @@ func (_ fastpathT) EncMapUint64Uint16V(v map[uint64]uint16, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64Uint32R(rv reflect.Value) {
-	fastpathTV.EncMapUint64Uint32V(rv2i(rv).(map[uint64]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64Uint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64Uint32V(rv2i(rv).(map[uint64]uint32), e)
 }
-func (_ fastpathT) EncMapUint64Uint32V(v map[uint64]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint64Uint32V(v map[uint64]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10302,43 +8131,40 @@ func (_ fastpathT) EncMapUint64Uint32V(v map[uint64]uint32, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64Uint64R(rv reflect.Value) {
-	fastpathTV.EncMapUint64Uint64V(rv2i(rv).(map[uint64]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64Uint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64Uint64V(rv2i(rv).(map[uint64]uint64), e)
 }
-func (_ fastpathT) EncMapUint64Uint64V(v map[uint64]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint64Uint64V(v map[uint64]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10348,43 +8174,40 @@ func (_ fastpathT) EncMapUint64Uint64V(v map[uint64]uint64, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uint64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64UintptrR(rv reflect.Value) {
-	fastpathTV.EncMapUint64UintptrV(rv2i(rv).(map[uint64]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64UintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64UintptrV(rv2i(rv).(map[uint64]uintptr), e)
 }
-func (_ fastpathT) EncMapUint64UintptrV(v map[uint64]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint64UintptrV(v map[uint64]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10394,43 +8217,40 @@ func (_ fastpathT) EncMapUint64UintptrV(v map[uint64]uintptr, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uint64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64IntR(rv reflect.Value) {
-	fastpathTV.EncMapUint64IntV(rv2i(rv).(map[uint64]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64IntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64IntV(rv2i(rv).(map[uint64]int), e)
 }
-func (_ fastpathT) EncMapUint64IntV(v map[uint64]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint64IntV(v map[uint64]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10440,43 +8260,40 @@ func (_ fastpathT) EncMapUint64IntV(v map[uint64]int, checkNil bool, e *Encoder)
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64Int8R(rv reflect.Value) {
-	fastpathTV.EncMapUint64Int8V(rv2i(rv).(map[uint64]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64Int8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64Int8V(rv2i(rv).(map[uint64]int8), e)
 }
-func (_ fastpathT) EncMapUint64Int8V(v map[uint64]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint64Int8V(v map[uint64]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10486,43 +8303,40 @@ func (_ fastpathT) EncMapUint64Int8V(v map[uint64]int8, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64Int16R(rv reflect.Value) {
-	fastpathTV.EncMapUint64Int16V(rv2i(rv).(map[uint64]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64Int16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64Int16V(rv2i(rv).(map[uint64]int16), e)
 }
-func (_ fastpathT) EncMapUint64Int16V(v map[uint64]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint64Int16V(v map[uint64]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10532,43 +8346,40 @@ func (_ fastpathT) EncMapUint64Int16V(v map[uint64]int16, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64Int32R(rv reflect.Value) {
-	fastpathTV.EncMapUint64Int32V(rv2i(rv).(map[uint64]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64Int32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64Int32V(rv2i(rv).(map[uint64]int32), e)
 }
-func (_ fastpathT) EncMapUint64Int32V(v map[uint64]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint64Int32V(v map[uint64]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10578,43 +8389,40 @@ func (_ fastpathT) EncMapUint64Int32V(v map[uint64]int32, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64Int64R(rv reflect.Value) {
-	fastpathTV.EncMapUint64Int64V(rv2i(rv).(map[uint64]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64Int64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64Int64V(rv2i(rv).(map[uint64]int64), e)
 }
-func (_ fastpathT) EncMapUint64Int64V(v map[uint64]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint64Int64V(v map[uint64]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10624,43 +8432,40 @@ func (_ fastpathT) EncMapUint64Int64V(v map[uint64]int64, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uint64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64Float32R(rv reflect.Value) {
-	fastpathTV.EncMapUint64Float32V(rv2i(rv).(map[uint64]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64Float32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64Float32V(rv2i(rv).(map[uint64]float32), e)
 }
-func (_ fastpathT) EncMapUint64Float32V(v map[uint64]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint64Float32V(v map[uint64]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10670,43 +8475,40 @@ func (_ fastpathT) EncMapUint64Float32V(v map[uint64]float32, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[uint64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64Float64R(rv reflect.Value) {
-	fastpathTV.EncMapUint64Float64V(rv2i(rv).(map[uint64]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64Float64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64Float64V(rv2i(rv).(map[uint64]float64), e)
 }
-func (_ fastpathT) EncMapUint64Float64V(v map[uint64]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint64Float64V(v map[uint64]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10716,43 +8518,40 @@ func (_ fastpathT) EncMapUint64Float64V(v map[uint64]float64, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[uint64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUint64BoolR(rv reflect.Value) {
-	fastpathTV.EncMapUint64BoolV(rv2i(rv).(map[uint64]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUint64BoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUint64BoolV(rv2i(rv).(map[uint64]bool), e)
 }
-func (_ fastpathT) EncMapUint64BoolV(v map[uint64]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUint64BoolV(v map[uint64]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10762,43 +8561,40 @@ func (_ fastpathT) EncMapUint64BoolV(v map[uint64]bool, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[uint64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrIntfR(rv reflect.Value) {
-	fastpathTV.EncMapUintptrIntfV(rv2i(rv).(map[uintptr]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrIntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrIntfV(rv2i(rv).(map[uintptr]interface{}), e)
 }
-func (_ fastpathT) EncMapUintptrIntfV(v map[uintptr]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintptrIntfV(v map[uintptr]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10808,43 +8604,40 @@ func (_ fastpathT) EncMapUintptrIntfV(v map[uintptr]interface{}, checkNil bool,
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uintptr(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrStringR(rv reflect.Value) {
-	fastpathTV.EncMapUintptrStringV(rv2i(rv).(map[uintptr]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrStringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrStringV(rv2i(rv).(map[uintptr]string), e)
 }
-func (_ fastpathT) EncMapUintptrStringV(v map[uintptr]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintptrStringV(v map[uintptr]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10854,43 +8647,40 @@ func (_ fastpathT) EncMapUintptrStringV(v map[uintptr]string, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v[uintptr(k2)])
+			ee.EncodeString(cUTF8, v[uintptr(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v2)
+			ee.EncodeString(cUTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrUintR(rv reflect.Value) {
-	fastpathTV.EncMapUintptrUintV(rv2i(rv).(map[uintptr]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrUintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrUintV(rv2i(rv).(map[uintptr]uint), e)
 }
-func (_ fastpathT) EncMapUintptrUintV(v map[uintptr]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintptrUintV(v map[uintptr]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10900,43 +8690,40 @@ func (_ fastpathT) EncMapUintptrUintV(v map[uintptr]uint, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uintptr(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrUint8R(rv reflect.Value) {
-	fastpathTV.EncMapUintptrUint8V(rv2i(rv).(map[uintptr]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrUint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrUint8V(rv2i(rv).(map[uintptr]uint8), e)
 }
-func (_ fastpathT) EncMapUintptrUint8V(v map[uintptr]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintptrUint8V(v map[uintptr]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10946,43 +8733,40 @@ func (_ fastpathT) EncMapUintptrUint8V(v map[uintptr]uint8, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uintptr(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrUint16R(rv reflect.Value) {
-	fastpathTV.EncMapUintptrUint16V(rv2i(rv).(map[uintptr]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrUint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrUint16V(rv2i(rv).(map[uintptr]uint16), e)
 }
-func (_ fastpathT) EncMapUintptrUint16V(v map[uintptr]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintptrUint16V(v map[uintptr]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10992,43 +8776,40 @@ func (_ fastpathT) EncMapUintptrUint16V(v map[uintptr]uint16, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uintptr(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrUint32R(rv reflect.Value) {
-	fastpathTV.EncMapUintptrUint32V(rv2i(rv).(map[uintptr]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrUint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrUint32V(rv2i(rv).(map[uintptr]uint32), e)
 }
-func (_ fastpathT) EncMapUintptrUint32V(v map[uintptr]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintptrUint32V(v map[uintptr]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11038,43 +8819,40 @@ func (_ fastpathT) EncMapUintptrUint32V(v map[uintptr]uint32, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uintptr(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrUint64R(rv reflect.Value) {
-	fastpathTV.EncMapUintptrUint64V(rv2i(rv).(map[uintptr]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrUint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrUint64V(rv2i(rv).(map[uintptr]uint64), e)
 }
-func (_ fastpathT) EncMapUintptrUint64V(v map[uintptr]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintptrUint64V(v map[uintptr]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11084,43 +8862,40 @@ func (_ fastpathT) EncMapUintptrUint64V(v map[uintptr]uint64, checkNil bool, e *
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[uintptr(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrUintptrR(rv reflect.Value) {
-	fastpathTV.EncMapUintptrUintptrV(rv2i(rv).(map[uintptr]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrUintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrUintptrV(rv2i(rv).(map[uintptr]uintptr), e)
 }
-func (_ fastpathT) EncMapUintptrUintptrV(v map[uintptr]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintptrUintptrV(v map[uintptr]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11130,43 +8905,40 @@ func (_ fastpathT) EncMapUintptrUintptrV(v map[uintptr]uintptr, checkNil bool, e
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[uintptr(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrIntR(rv reflect.Value) {
-	fastpathTV.EncMapUintptrIntV(rv2i(rv).(map[uintptr]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrIntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrIntV(rv2i(rv).(map[uintptr]int), e)
 }
-func (_ fastpathT) EncMapUintptrIntV(v map[uintptr]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintptrIntV(v map[uintptr]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11176,43 +8948,40 @@ func (_ fastpathT) EncMapUintptrIntV(v map[uintptr]int, checkNil bool, e *Encode
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uintptr(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrInt8R(rv reflect.Value) {
-	fastpathTV.EncMapUintptrInt8V(rv2i(rv).(map[uintptr]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrInt8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrInt8V(rv2i(rv).(map[uintptr]int8), e)
 }
-func (_ fastpathT) EncMapUintptrInt8V(v map[uintptr]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintptrInt8V(v map[uintptr]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11222,43 +8991,40 @@ func (_ fastpathT) EncMapUintptrInt8V(v map[uintptr]int8, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uintptr(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrInt16R(rv reflect.Value) {
-	fastpathTV.EncMapUintptrInt16V(rv2i(rv).(map[uintptr]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrInt16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrInt16V(rv2i(rv).(map[uintptr]int16), e)
 }
-func (_ fastpathT) EncMapUintptrInt16V(v map[uintptr]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintptrInt16V(v map[uintptr]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11268,43 +9034,40 @@ func (_ fastpathT) EncMapUintptrInt16V(v map[uintptr]int16, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uintptr(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrInt32R(rv reflect.Value) {
-	fastpathTV.EncMapUintptrInt32V(rv2i(rv).(map[uintptr]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrInt32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrInt32V(rv2i(rv).(map[uintptr]int32), e)
 }
-func (_ fastpathT) EncMapUintptrInt32V(v map[uintptr]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintptrInt32V(v map[uintptr]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11314,43 +9077,40 @@ func (_ fastpathT) EncMapUintptrInt32V(v map[uintptr]int32, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uintptr(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrInt64R(rv reflect.Value) {
-	fastpathTV.EncMapUintptrInt64V(rv2i(rv).(map[uintptr]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrInt64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrInt64V(rv2i(rv).(map[uintptr]int64), e)
 }
-func (_ fastpathT) EncMapUintptrInt64V(v map[uintptr]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintptrInt64V(v map[uintptr]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11360,43 +9120,40 @@ func (_ fastpathT) EncMapUintptrInt64V(v map[uintptr]int64, checkNil bool, e *En
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[uintptr(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrFloat32R(rv reflect.Value) {
-	fastpathTV.EncMapUintptrFloat32V(rv2i(rv).(map[uintptr]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrFloat32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrFloat32V(rv2i(rv).(map[uintptr]float32), e)
 }
-func (_ fastpathT) EncMapUintptrFloat32V(v map[uintptr]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintptrFloat32V(v map[uintptr]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11406,43 +9163,40 @@ func (_ fastpathT) EncMapUintptrFloat32V(v map[uintptr]float32, checkNil bool, e
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[uintptr(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrFloat64R(rv reflect.Value) {
-	fastpathTV.EncMapUintptrFloat64V(rv2i(rv).(map[uintptr]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrFloat64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrFloat64V(rv2i(rv).(map[uintptr]float64), e)
 }
-func (_ fastpathT) EncMapUintptrFloat64V(v map[uintptr]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintptrFloat64V(v map[uintptr]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11452,43 +9206,40 @@ func (_ fastpathT) EncMapUintptrFloat64V(v map[uintptr]float64, checkNil bool, e
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[uintptr(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapUintptrBoolR(rv reflect.Value) {
-	fastpathTV.EncMapUintptrBoolV(rv2i(rv).(map[uintptr]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapUintptrBoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapUintptrBoolV(rv2i(rv).(map[uintptr]bool), e)
 }
-func (_ fastpathT) EncMapUintptrBoolV(v map[uintptr]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapUintptrBoolV(v map[uintptr]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11498,43 +9249,40 @@ func (_ fastpathT) EncMapUintptrBoolV(v map[uintptr]bool, checkNil bool, e *Enco
 		}
 		sort.Sort(uintSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[uintptr(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntIntfR(rv reflect.Value) {
-	fastpathTV.EncMapIntIntfV(rv2i(rv).(map[int]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntIntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntIntfV(rv2i(rv).(map[int]interface{}), e)
 }
-func (_ fastpathT) EncMapIntIntfV(v map[int]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntIntfV(v map[int]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11544,43 +9292,40 @@ func (_ fastpathT) EncMapIntIntfV(v map[int]interface{}, checkNil bool, e *Encod
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[int(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntStringR(rv reflect.Value) {
-	fastpathTV.EncMapIntStringV(rv2i(rv).(map[int]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntStringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntStringV(rv2i(rv).(map[int]string), e)
 }
-func (_ fastpathT) EncMapIntStringV(v map[int]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntStringV(v map[int]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11590,43 +9335,40 @@ func (_ fastpathT) EncMapIntStringV(v map[int]string, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v[int(k2)])
+			ee.EncodeString(cUTF8, v[int(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v2)
+			ee.EncodeString(cUTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntUintR(rv reflect.Value) {
-	fastpathTV.EncMapIntUintV(rv2i(rv).(map[int]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntUintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntUintV(rv2i(rv).(map[int]uint), e)
 }
-func (_ fastpathT) EncMapIntUintV(v map[int]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntUintV(v map[int]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11636,43 +9378,40 @@ func (_ fastpathT) EncMapIntUintV(v map[int]uint, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntUint8R(rv reflect.Value) {
-	fastpathTV.EncMapIntUint8V(rv2i(rv).(map[int]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntUint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntUint8V(rv2i(rv).(map[int]uint8), e)
 }
-func (_ fastpathT) EncMapIntUint8V(v map[int]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntUint8V(v map[int]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11682,43 +9421,40 @@ func (_ fastpathT) EncMapIntUint8V(v map[int]uint8, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntUint16R(rv reflect.Value) {
-	fastpathTV.EncMapIntUint16V(rv2i(rv).(map[int]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntUint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntUint16V(rv2i(rv).(map[int]uint16), e)
 }
-func (_ fastpathT) EncMapIntUint16V(v map[int]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntUint16V(v map[int]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11728,43 +9464,40 @@ func (_ fastpathT) EncMapIntUint16V(v map[int]uint16, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntUint32R(rv reflect.Value) {
-	fastpathTV.EncMapIntUint32V(rv2i(rv).(map[int]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntUint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntUint32V(rv2i(rv).(map[int]uint32), e)
 }
-func (_ fastpathT) EncMapIntUint32V(v map[int]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntUint32V(v map[int]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11774,43 +9507,40 @@ func (_ fastpathT) EncMapIntUint32V(v map[int]uint32, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntUint64R(rv reflect.Value) {
-	fastpathTV.EncMapIntUint64V(rv2i(rv).(map[int]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntUint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntUint64V(rv2i(rv).(map[int]uint64), e)
 }
-func (_ fastpathT) EncMapIntUint64V(v map[int]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntUint64V(v map[int]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11820,43 +9550,40 @@ func (_ fastpathT) EncMapIntUint64V(v map[int]uint64, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntUintptrR(rv reflect.Value) {
-	fastpathTV.EncMapIntUintptrV(rv2i(rv).(map[int]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntUintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntUintptrV(rv2i(rv).(map[int]uintptr), e)
 }
-func (_ fastpathT) EncMapIntUintptrV(v map[int]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntUintptrV(v map[int]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11866,43 +9593,40 @@ func (_ fastpathT) EncMapIntUintptrV(v map[int]uintptr, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[int(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntIntR(rv reflect.Value) {
-	fastpathTV.EncMapIntIntV(rv2i(rv).(map[int]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntIntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntIntV(rv2i(rv).(map[int]int), e)
 }
-func (_ fastpathT) EncMapIntIntV(v map[int]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntIntV(v map[int]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11912,43 +9636,40 @@ func (_ fastpathT) EncMapIntIntV(v map[int]int, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntInt8R(rv reflect.Value) {
-	fastpathTV.EncMapIntInt8V(rv2i(rv).(map[int]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntInt8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntInt8V(rv2i(rv).(map[int]int8), e)
 }
-func (_ fastpathT) EncMapIntInt8V(v map[int]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntInt8V(v map[int]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11958,43 +9679,40 @@ func (_ fastpathT) EncMapIntInt8V(v map[int]int8, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntInt16R(rv reflect.Value) {
-	fastpathTV.EncMapIntInt16V(rv2i(rv).(map[int]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntInt16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntInt16V(rv2i(rv).(map[int]int16), e)
 }
-func (_ fastpathT) EncMapIntInt16V(v map[int]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntInt16V(v map[int]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12004,43 +9722,40 @@ func (_ fastpathT) EncMapIntInt16V(v map[int]int16, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntInt32R(rv reflect.Value) {
-	fastpathTV.EncMapIntInt32V(rv2i(rv).(map[int]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntInt32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntInt32V(rv2i(rv).(map[int]int32), e)
 }
-func (_ fastpathT) EncMapIntInt32V(v map[int]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntInt32V(v map[int]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12050,43 +9765,40 @@ func (_ fastpathT) EncMapIntInt32V(v map[int]int32, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntInt64R(rv reflect.Value) {
-	fastpathTV.EncMapIntInt64V(rv2i(rv).(map[int]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntInt64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntInt64V(rv2i(rv).(map[int]int64), e)
 }
-func (_ fastpathT) EncMapIntInt64V(v map[int]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntInt64V(v map[int]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12096,43 +9808,40 @@ func (_ fastpathT) EncMapIntInt64V(v map[int]int64, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntFloat32R(rv reflect.Value) {
-	fastpathTV.EncMapIntFloat32V(rv2i(rv).(map[int]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntFloat32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntFloat32V(rv2i(rv).(map[int]float32), e)
 }
-func (_ fastpathT) EncMapIntFloat32V(v map[int]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntFloat32V(v map[int]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12142,43 +9851,40 @@ func (_ fastpathT) EncMapIntFloat32V(v map[int]float32, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[int(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntFloat64R(rv reflect.Value) {
-	fastpathTV.EncMapIntFloat64V(rv2i(rv).(map[int]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntFloat64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntFloat64V(rv2i(rv).(map[int]float64), e)
 }
-func (_ fastpathT) EncMapIntFloat64V(v map[int]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntFloat64V(v map[int]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12188,43 +9894,40 @@ func (_ fastpathT) EncMapIntFloat64V(v map[int]float64, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[int(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapIntBoolR(rv reflect.Value) {
-	fastpathTV.EncMapIntBoolV(rv2i(rv).(map[int]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapIntBoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntBoolV(rv2i(rv).(map[int]bool), e)
 }
-func (_ fastpathT) EncMapIntBoolV(v map[int]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapIntBoolV(v map[int]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12234,43 +9937,40 @@ func (_ fastpathT) EncMapIntBoolV(v map[int]bool, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[int(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8IntfR(rv reflect.Value) {
-	fastpathTV.EncMapInt8IntfV(rv2i(rv).(map[int8]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8IntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8IntfV(rv2i(rv).(map[int8]interface{}), e)
 }
-func (_ fastpathT) EncMapInt8IntfV(v map[int8]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt8IntfV(v map[int8]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12280,43 +9980,40 @@ func (_ fastpathT) EncMapInt8IntfV(v map[int8]interface{}, checkNil bool, e *Enc
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[int8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8StringR(rv reflect.Value) {
-	fastpathTV.EncMapInt8StringV(rv2i(rv).(map[int8]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8StringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8StringV(rv2i(rv).(map[int8]string), e)
 }
-func (_ fastpathT) EncMapInt8StringV(v map[int8]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt8StringV(v map[int8]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12326,43 +10023,40 @@ func (_ fastpathT) EncMapInt8StringV(v map[int8]string, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v[int8(k2)])
+			ee.EncodeString(cUTF8, v[int8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v2)
+			ee.EncodeString(cUTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8UintR(rv reflect.Value) {
-	fastpathTV.EncMapInt8UintV(rv2i(rv).(map[int8]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8UintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8UintV(rv2i(rv).(map[int8]uint), e)
 }
-func (_ fastpathT) EncMapInt8UintV(v map[int8]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt8UintV(v map[int8]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12372,43 +10066,40 @@ func (_ fastpathT) EncMapInt8UintV(v map[int8]uint, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8Uint8R(rv reflect.Value) {
-	fastpathTV.EncMapInt8Uint8V(rv2i(rv).(map[int8]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8Uint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8Uint8V(rv2i(rv).(map[int8]uint8), e)
 }
-func (_ fastpathT) EncMapInt8Uint8V(v map[int8]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt8Uint8V(v map[int8]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12418,43 +10109,40 @@ func (_ fastpathT) EncMapInt8Uint8V(v map[int8]uint8, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8Uint16R(rv reflect.Value) {
-	fastpathTV.EncMapInt8Uint16V(rv2i(rv).(map[int8]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8Uint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8Uint16V(rv2i(rv).(map[int8]uint16), e)
 }
-func (_ fastpathT) EncMapInt8Uint16V(v map[int8]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt8Uint16V(v map[int8]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12464,43 +10152,40 @@ func (_ fastpathT) EncMapInt8Uint16V(v map[int8]uint16, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8Uint32R(rv reflect.Value) {
-	fastpathTV.EncMapInt8Uint32V(rv2i(rv).(map[int8]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8Uint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8Uint32V(rv2i(rv).(map[int8]uint32), e)
 }
-func (_ fastpathT) EncMapInt8Uint32V(v map[int8]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt8Uint32V(v map[int8]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12510,43 +10195,40 @@ func (_ fastpathT) EncMapInt8Uint32V(v map[int8]uint32, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8Uint64R(rv reflect.Value) {
-	fastpathTV.EncMapInt8Uint64V(rv2i(rv).(map[int8]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8Uint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8Uint64V(rv2i(rv).(map[int8]uint64), e)
 }
-func (_ fastpathT) EncMapInt8Uint64V(v map[int8]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt8Uint64V(v map[int8]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12556,43 +10238,40 @@ func (_ fastpathT) EncMapInt8Uint64V(v map[int8]uint64, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8UintptrR(rv reflect.Value) {
-	fastpathTV.EncMapInt8UintptrV(rv2i(rv).(map[int8]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8UintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8UintptrV(rv2i(rv).(map[int8]uintptr), e)
 }
-func (_ fastpathT) EncMapInt8UintptrV(v map[int8]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt8UintptrV(v map[int8]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12602,43 +10281,40 @@ func (_ fastpathT) EncMapInt8UintptrV(v map[int8]uintptr, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[int8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8IntR(rv reflect.Value) {
-	fastpathTV.EncMapInt8IntV(rv2i(rv).(map[int8]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8IntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8IntV(rv2i(rv).(map[int8]int), e)
 }
-func (_ fastpathT) EncMapInt8IntV(v map[int8]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt8IntV(v map[int8]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12648,43 +10324,40 @@ func (_ fastpathT) EncMapInt8IntV(v map[int8]int, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8Int8R(rv reflect.Value) {
-	fastpathTV.EncMapInt8Int8V(rv2i(rv).(map[int8]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8Int8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8Int8V(rv2i(rv).(map[int8]int8), e)
 }
-func (_ fastpathT) EncMapInt8Int8V(v map[int8]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt8Int8V(v map[int8]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12694,43 +10367,40 @@ func (_ fastpathT) EncMapInt8Int8V(v map[int8]int8, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8Int16R(rv reflect.Value) {
-	fastpathTV.EncMapInt8Int16V(rv2i(rv).(map[int8]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8Int16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8Int16V(rv2i(rv).(map[int8]int16), e)
 }
-func (_ fastpathT) EncMapInt8Int16V(v map[int8]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt8Int16V(v map[int8]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12740,43 +10410,40 @@ func (_ fastpathT) EncMapInt8Int16V(v map[int8]int16, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8Int32R(rv reflect.Value) {
-	fastpathTV.EncMapInt8Int32V(rv2i(rv).(map[int8]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8Int32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8Int32V(rv2i(rv).(map[int8]int32), e)
 }
-func (_ fastpathT) EncMapInt8Int32V(v map[int8]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt8Int32V(v map[int8]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12786,43 +10453,40 @@ func (_ fastpathT) EncMapInt8Int32V(v map[int8]int32, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8Int64R(rv reflect.Value) {
-	fastpathTV.EncMapInt8Int64V(rv2i(rv).(map[int8]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8Int64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8Int64V(rv2i(rv).(map[int8]int64), e)
 }
-func (_ fastpathT) EncMapInt8Int64V(v map[int8]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt8Int64V(v map[int8]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12832,43 +10496,40 @@ func (_ fastpathT) EncMapInt8Int64V(v map[int8]int64, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int8(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8Float32R(rv reflect.Value) {
-	fastpathTV.EncMapInt8Float32V(rv2i(rv).(map[int8]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8Float32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8Float32V(rv2i(rv).(map[int8]float32), e)
 }
-func (_ fastpathT) EncMapInt8Float32V(v map[int8]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt8Float32V(v map[int8]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12878,43 +10539,40 @@ func (_ fastpathT) EncMapInt8Float32V(v map[int8]float32, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[int8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8Float64R(rv reflect.Value) {
-	fastpathTV.EncMapInt8Float64V(rv2i(rv).(map[int8]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8Float64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8Float64V(rv2i(rv).(map[int8]float64), e)
 }
-func (_ fastpathT) EncMapInt8Float64V(v map[int8]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt8Float64V(v map[int8]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12924,43 +10582,40 @@ func (_ fastpathT) EncMapInt8Float64V(v map[int8]float64, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[int8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt8BoolR(rv reflect.Value) {
-	fastpathTV.EncMapInt8BoolV(rv2i(rv).(map[int8]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt8BoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt8BoolV(rv2i(rv).(map[int8]bool), e)
 }
-func (_ fastpathT) EncMapInt8BoolV(v map[int8]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt8BoolV(v map[int8]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12970,43 +10625,40 @@ func (_ fastpathT) EncMapInt8BoolV(v map[int8]bool, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[int8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16IntfR(rv reflect.Value) {
-	fastpathTV.EncMapInt16IntfV(rv2i(rv).(map[int16]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16IntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16IntfV(rv2i(rv).(map[int16]interface{}), e)
 }
-func (_ fastpathT) EncMapInt16IntfV(v map[int16]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt16IntfV(v map[int16]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13016,43 +10668,40 @@ func (_ fastpathT) EncMapInt16IntfV(v map[int16]interface{}, checkNil bool, e *E
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[int16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16StringR(rv reflect.Value) {
-	fastpathTV.EncMapInt16StringV(rv2i(rv).(map[int16]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16StringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16StringV(rv2i(rv).(map[int16]string), e)
 }
-func (_ fastpathT) EncMapInt16StringV(v map[int16]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt16StringV(v map[int16]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13062,43 +10711,40 @@ func (_ fastpathT) EncMapInt16StringV(v map[int16]string, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v[int16(k2)])
+			ee.EncodeString(cUTF8, v[int16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v2)
+			ee.EncodeString(cUTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16UintR(rv reflect.Value) {
-	fastpathTV.EncMapInt16UintV(rv2i(rv).(map[int16]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16UintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16UintV(rv2i(rv).(map[int16]uint), e)
 }
-func (_ fastpathT) EncMapInt16UintV(v map[int16]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt16UintV(v map[int16]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13108,43 +10754,40 @@ func (_ fastpathT) EncMapInt16UintV(v map[int16]uint, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16Uint8R(rv reflect.Value) {
-	fastpathTV.EncMapInt16Uint8V(rv2i(rv).(map[int16]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16Uint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16Uint8V(rv2i(rv).(map[int16]uint8), e)
 }
-func (_ fastpathT) EncMapInt16Uint8V(v map[int16]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt16Uint8V(v map[int16]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13154,43 +10797,40 @@ func (_ fastpathT) EncMapInt16Uint8V(v map[int16]uint8, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16Uint16R(rv reflect.Value) {
-	fastpathTV.EncMapInt16Uint16V(rv2i(rv).(map[int16]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16Uint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16Uint16V(rv2i(rv).(map[int16]uint16), e)
 }
-func (_ fastpathT) EncMapInt16Uint16V(v map[int16]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt16Uint16V(v map[int16]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13200,43 +10840,40 @@ func (_ fastpathT) EncMapInt16Uint16V(v map[int16]uint16, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16Uint32R(rv reflect.Value) {
-	fastpathTV.EncMapInt16Uint32V(rv2i(rv).(map[int16]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16Uint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16Uint32V(rv2i(rv).(map[int16]uint32), e)
 }
-func (_ fastpathT) EncMapInt16Uint32V(v map[int16]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt16Uint32V(v map[int16]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13246,43 +10883,40 @@ func (_ fastpathT) EncMapInt16Uint32V(v map[int16]uint32, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16Uint64R(rv reflect.Value) {
-	fastpathTV.EncMapInt16Uint64V(rv2i(rv).(map[int16]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16Uint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16Uint64V(rv2i(rv).(map[int16]uint64), e)
 }
-func (_ fastpathT) EncMapInt16Uint64V(v map[int16]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt16Uint64V(v map[int16]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13292,43 +10926,40 @@ func (_ fastpathT) EncMapInt16Uint64V(v map[int16]uint64, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16UintptrR(rv reflect.Value) {
-	fastpathTV.EncMapInt16UintptrV(rv2i(rv).(map[int16]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16UintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16UintptrV(rv2i(rv).(map[int16]uintptr), e)
 }
-func (_ fastpathT) EncMapInt16UintptrV(v map[int16]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt16UintptrV(v map[int16]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13338,43 +10969,40 @@ func (_ fastpathT) EncMapInt16UintptrV(v map[int16]uintptr, checkNil bool, e *En
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[int16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16IntR(rv reflect.Value) {
-	fastpathTV.EncMapInt16IntV(rv2i(rv).(map[int16]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16IntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16IntV(rv2i(rv).(map[int16]int), e)
 }
-func (_ fastpathT) EncMapInt16IntV(v map[int16]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt16IntV(v map[int16]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13384,43 +11012,40 @@ func (_ fastpathT) EncMapInt16IntV(v map[int16]int, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16Int8R(rv reflect.Value) {
-	fastpathTV.EncMapInt16Int8V(rv2i(rv).(map[int16]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16Int8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16Int8V(rv2i(rv).(map[int16]int8), e)
 }
-func (_ fastpathT) EncMapInt16Int8V(v map[int16]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt16Int8V(v map[int16]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13430,43 +11055,40 @@ func (_ fastpathT) EncMapInt16Int8V(v map[int16]int8, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16Int16R(rv reflect.Value) {
-	fastpathTV.EncMapInt16Int16V(rv2i(rv).(map[int16]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16Int16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16Int16V(rv2i(rv).(map[int16]int16), e)
 }
-func (_ fastpathT) EncMapInt16Int16V(v map[int16]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt16Int16V(v map[int16]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13476,43 +11098,40 @@ func (_ fastpathT) EncMapInt16Int16V(v map[int16]int16, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16Int32R(rv reflect.Value) {
-	fastpathTV.EncMapInt16Int32V(rv2i(rv).(map[int16]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16Int32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16Int32V(rv2i(rv).(map[int16]int32), e)
 }
-func (_ fastpathT) EncMapInt16Int32V(v map[int16]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt16Int32V(v map[int16]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13522,43 +11141,40 @@ func (_ fastpathT) EncMapInt16Int32V(v map[int16]int32, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16Int64R(rv reflect.Value) {
-	fastpathTV.EncMapInt16Int64V(rv2i(rv).(map[int16]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16Int64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16Int64V(rv2i(rv).(map[int16]int64), e)
 }
-func (_ fastpathT) EncMapInt16Int64V(v map[int16]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt16Int64V(v map[int16]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13568,43 +11184,40 @@ func (_ fastpathT) EncMapInt16Int64V(v map[int16]int64, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int16(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16Float32R(rv reflect.Value) {
-	fastpathTV.EncMapInt16Float32V(rv2i(rv).(map[int16]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16Float32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16Float32V(rv2i(rv).(map[int16]float32), e)
 }
-func (_ fastpathT) EncMapInt16Float32V(v map[int16]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt16Float32V(v map[int16]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13614,43 +11227,40 @@ func (_ fastpathT) EncMapInt16Float32V(v map[int16]float32, checkNil bool, e *En
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[int16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16Float64R(rv reflect.Value) {
-	fastpathTV.EncMapInt16Float64V(rv2i(rv).(map[int16]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16Float64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16Float64V(rv2i(rv).(map[int16]float64), e)
 }
-func (_ fastpathT) EncMapInt16Float64V(v map[int16]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt16Float64V(v map[int16]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13660,43 +11270,40 @@ func (_ fastpathT) EncMapInt16Float64V(v map[int16]float64, checkNil bool, e *En
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[int16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt16BoolR(rv reflect.Value) {
-	fastpathTV.EncMapInt16BoolV(rv2i(rv).(map[int16]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt16BoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt16BoolV(rv2i(rv).(map[int16]bool), e)
 }
-func (_ fastpathT) EncMapInt16BoolV(v map[int16]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt16BoolV(v map[int16]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13706,43 +11313,40 @@ func (_ fastpathT) EncMapInt16BoolV(v map[int16]bool, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[int16(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32IntfR(rv reflect.Value) {
-	fastpathTV.EncMapInt32IntfV(rv2i(rv).(map[int32]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32IntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32IntfV(rv2i(rv).(map[int32]interface{}), e)
 }
-func (_ fastpathT) EncMapInt32IntfV(v map[int32]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt32IntfV(v map[int32]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13752,43 +11356,40 @@ func (_ fastpathT) EncMapInt32IntfV(v map[int32]interface{}, checkNil bool, e *E
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[int32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32StringR(rv reflect.Value) {
-	fastpathTV.EncMapInt32StringV(rv2i(rv).(map[int32]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32StringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32StringV(rv2i(rv).(map[int32]string), e)
 }
-func (_ fastpathT) EncMapInt32StringV(v map[int32]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt32StringV(v map[int32]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13798,43 +11399,40 @@ func (_ fastpathT) EncMapInt32StringV(v map[int32]string, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v[int32(k2)])
+			ee.EncodeString(cUTF8, v[int32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v2)
+			ee.EncodeString(cUTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32UintR(rv reflect.Value) {
-	fastpathTV.EncMapInt32UintV(rv2i(rv).(map[int32]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32UintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32UintV(rv2i(rv).(map[int32]uint), e)
 }
-func (_ fastpathT) EncMapInt32UintV(v map[int32]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt32UintV(v map[int32]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13844,43 +11442,40 @@ func (_ fastpathT) EncMapInt32UintV(v map[int32]uint, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32Uint8R(rv reflect.Value) {
-	fastpathTV.EncMapInt32Uint8V(rv2i(rv).(map[int32]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32Uint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32Uint8V(rv2i(rv).(map[int32]uint8), e)
 }
-func (_ fastpathT) EncMapInt32Uint8V(v map[int32]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt32Uint8V(v map[int32]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13890,43 +11485,40 @@ func (_ fastpathT) EncMapInt32Uint8V(v map[int32]uint8, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32Uint16R(rv reflect.Value) {
-	fastpathTV.EncMapInt32Uint16V(rv2i(rv).(map[int32]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32Uint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32Uint16V(rv2i(rv).(map[int32]uint16), e)
 }
-func (_ fastpathT) EncMapInt32Uint16V(v map[int32]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt32Uint16V(v map[int32]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13936,43 +11528,40 @@ func (_ fastpathT) EncMapInt32Uint16V(v map[int32]uint16, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32Uint32R(rv reflect.Value) {
-	fastpathTV.EncMapInt32Uint32V(rv2i(rv).(map[int32]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32Uint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32Uint32V(rv2i(rv).(map[int32]uint32), e)
 }
-func (_ fastpathT) EncMapInt32Uint32V(v map[int32]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt32Uint32V(v map[int32]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13982,43 +11571,40 @@ func (_ fastpathT) EncMapInt32Uint32V(v map[int32]uint32, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32Uint64R(rv reflect.Value) {
-	fastpathTV.EncMapInt32Uint64V(rv2i(rv).(map[int32]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32Uint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32Uint64V(rv2i(rv).(map[int32]uint64), e)
 }
-func (_ fastpathT) EncMapInt32Uint64V(v map[int32]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt32Uint64V(v map[int32]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14028,43 +11614,40 @@ func (_ fastpathT) EncMapInt32Uint64V(v map[int32]uint64, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32UintptrR(rv reflect.Value) {
-	fastpathTV.EncMapInt32UintptrV(rv2i(rv).(map[int32]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32UintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32UintptrV(rv2i(rv).(map[int32]uintptr), e)
 }
-func (_ fastpathT) EncMapInt32UintptrV(v map[int32]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt32UintptrV(v map[int32]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14074,43 +11657,40 @@ func (_ fastpathT) EncMapInt32UintptrV(v map[int32]uintptr, checkNil bool, e *En
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[int32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32IntR(rv reflect.Value) {
-	fastpathTV.EncMapInt32IntV(rv2i(rv).(map[int32]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32IntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32IntV(rv2i(rv).(map[int32]int), e)
 }
-func (_ fastpathT) EncMapInt32IntV(v map[int32]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt32IntV(v map[int32]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14120,43 +11700,40 @@ func (_ fastpathT) EncMapInt32IntV(v map[int32]int, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32Int8R(rv reflect.Value) {
-	fastpathTV.EncMapInt32Int8V(rv2i(rv).(map[int32]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32Int8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32Int8V(rv2i(rv).(map[int32]int8), e)
 }
-func (_ fastpathT) EncMapInt32Int8V(v map[int32]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt32Int8V(v map[int32]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14166,43 +11743,40 @@ func (_ fastpathT) EncMapInt32Int8V(v map[int32]int8, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32Int16R(rv reflect.Value) {
-	fastpathTV.EncMapInt32Int16V(rv2i(rv).(map[int32]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32Int16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32Int16V(rv2i(rv).(map[int32]int16), e)
 }
-func (_ fastpathT) EncMapInt32Int16V(v map[int32]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt32Int16V(v map[int32]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14212,43 +11786,40 @@ func (_ fastpathT) EncMapInt32Int16V(v map[int32]int16, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32Int32R(rv reflect.Value) {
-	fastpathTV.EncMapInt32Int32V(rv2i(rv).(map[int32]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32Int32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32Int32V(rv2i(rv).(map[int32]int32), e)
 }
-func (_ fastpathT) EncMapInt32Int32V(v map[int32]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt32Int32V(v map[int32]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14258,43 +11829,40 @@ func (_ fastpathT) EncMapInt32Int32V(v map[int32]int32, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32Int64R(rv reflect.Value) {
-	fastpathTV.EncMapInt32Int64V(rv2i(rv).(map[int32]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32Int64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32Int64V(rv2i(rv).(map[int32]int64), e)
 }
-func (_ fastpathT) EncMapInt32Int64V(v map[int32]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt32Int64V(v map[int32]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14304,43 +11872,40 @@ func (_ fastpathT) EncMapInt32Int64V(v map[int32]int64, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int32(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32Float32R(rv reflect.Value) {
-	fastpathTV.EncMapInt32Float32V(rv2i(rv).(map[int32]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32Float32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32Float32V(rv2i(rv).(map[int32]float32), e)
 }
-func (_ fastpathT) EncMapInt32Float32V(v map[int32]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt32Float32V(v map[int32]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14350,43 +11915,40 @@ func (_ fastpathT) EncMapInt32Float32V(v map[int32]float32, checkNil bool, e *En
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[int32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32Float64R(rv reflect.Value) {
-	fastpathTV.EncMapInt32Float64V(rv2i(rv).(map[int32]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32Float64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32Float64V(rv2i(rv).(map[int32]float64), e)
 }
-func (_ fastpathT) EncMapInt32Float64V(v map[int32]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt32Float64V(v map[int32]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14396,43 +11958,40 @@ func (_ fastpathT) EncMapInt32Float64V(v map[int32]float64, checkNil bool, e *En
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[int32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt32BoolR(rv reflect.Value) {
-	fastpathTV.EncMapInt32BoolV(rv2i(rv).(map[int32]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt32BoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt32BoolV(rv2i(rv).(map[int32]bool), e)
 }
-func (_ fastpathT) EncMapInt32BoolV(v map[int32]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt32BoolV(v map[int32]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14442,43 +12001,40 @@ func (_ fastpathT) EncMapInt32BoolV(v map[int32]bool, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[int32(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64IntfR(rv reflect.Value) {
-	fastpathTV.EncMapInt64IntfV(rv2i(rv).(map[int64]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64IntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64IntfV(rv2i(rv).(map[int64]interface{}), e)
 }
-func (_ fastpathT) EncMapInt64IntfV(v map[int64]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt64IntfV(v map[int64]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14488,43 +12044,40 @@ func (_ fastpathT) EncMapInt64IntfV(v map[int64]interface{}, checkNil bool, e *E
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[int64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64StringR(rv reflect.Value) {
-	fastpathTV.EncMapInt64StringV(rv2i(rv).(map[int64]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64StringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64StringV(rv2i(rv).(map[int64]string), e)
 }
-func (_ fastpathT) EncMapInt64StringV(v map[int64]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt64StringV(v map[int64]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14534,43 +12087,40 @@ func (_ fastpathT) EncMapInt64StringV(v map[int64]string, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v[int64(k2)])
+			ee.EncodeString(cUTF8, v[int64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v2)
+			ee.EncodeString(cUTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64UintR(rv reflect.Value) {
-	fastpathTV.EncMapInt64UintV(rv2i(rv).(map[int64]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64UintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64UintV(rv2i(rv).(map[int64]uint), e)
 }
-func (_ fastpathT) EncMapInt64UintV(v map[int64]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt64UintV(v map[int64]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14580,43 +12130,40 @@ func (_ fastpathT) EncMapInt64UintV(v map[int64]uint, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64Uint8R(rv reflect.Value) {
-	fastpathTV.EncMapInt64Uint8V(rv2i(rv).(map[int64]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64Uint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64Uint8V(rv2i(rv).(map[int64]uint8), e)
 }
-func (_ fastpathT) EncMapInt64Uint8V(v map[int64]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt64Uint8V(v map[int64]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14626,43 +12173,40 @@ func (_ fastpathT) EncMapInt64Uint8V(v map[int64]uint8, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64Uint16R(rv reflect.Value) {
-	fastpathTV.EncMapInt64Uint16V(rv2i(rv).(map[int64]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64Uint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64Uint16V(rv2i(rv).(map[int64]uint16), e)
 }
-func (_ fastpathT) EncMapInt64Uint16V(v map[int64]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt64Uint16V(v map[int64]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14672,43 +12216,40 @@ func (_ fastpathT) EncMapInt64Uint16V(v map[int64]uint16, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64Uint32R(rv reflect.Value) {
-	fastpathTV.EncMapInt64Uint32V(rv2i(rv).(map[int64]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64Uint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64Uint32V(rv2i(rv).(map[int64]uint32), e)
 }
-func (_ fastpathT) EncMapInt64Uint32V(v map[int64]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt64Uint32V(v map[int64]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14718,43 +12259,40 @@ func (_ fastpathT) EncMapInt64Uint32V(v map[int64]uint32, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64Uint64R(rv reflect.Value) {
-	fastpathTV.EncMapInt64Uint64V(rv2i(rv).(map[int64]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64Uint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64Uint64V(rv2i(rv).(map[int64]uint64), e)
 }
-func (_ fastpathT) EncMapInt64Uint64V(v map[int64]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt64Uint64V(v map[int64]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14764,43 +12302,40 @@ func (_ fastpathT) EncMapInt64Uint64V(v map[int64]uint64, checkNil bool, e *Enco
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[int64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64UintptrR(rv reflect.Value) {
-	fastpathTV.EncMapInt64UintptrV(rv2i(rv).(map[int64]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64UintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64UintptrV(rv2i(rv).(map[int64]uintptr), e)
 }
-func (_ fastpathT) EncMapInt64UintptrV(v map[int64]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt64UintptrV(v map[int64]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14810,43 +12345,40 @@ func (_ fastpathT) EncMapInt64UintptrV(v map[int64]uintptr, checkNil bool, e *En
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[int64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64IntR(rv reflect.Value) {
-	fastpathTV.EncMapInt64IntV(rv2i(rv).(map[int64]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64IntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64IntV(rv2i(rv).(map[int64]int), e)
 }
-func (_ fastpathT) EncMapInt64IntV(v map[int64]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt64IntV(v map[int64]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14856,43 +12388,40 @@ func (_ fastpathT) EncMapInt64IntV(v map[int64]int, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64Int8R(rv reflect.Value) {
-	fastpathTV.EncMapInt64Int8V(rv2i(rv).(map[int64]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64Int8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64Int8V(rv2i(rv).(map[int64]int8), e)
 }
-func (_ fastpathT) EncMapInt64Int8V(v map[int64]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt64Int8V(v map[int64]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14902,43 +12431,40 @@ func (_ fastpathT) EncMapInt64Int8V(v map[int64]int8, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64Int16R(rv reflect.Value) {
-	fastpathTV.EncMapInt64Int16V(rv2i(rv).(map[int64]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64Int16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64Int16V(rv2i(rv).(map[int64]int16), e)
 }
-func (_ fastpathT) EncMapInt64Int16V(v map[int64]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt64Int16V(v map[int64]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14948,43 +12474,40 @@ func (_ fastpathT) EncMapInt64Int16V(v map[int64]int16, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64Int32R(rv reflect.Value) {
-	fastpathTV.EncMapInt64Int32V(rv2i(rv).(map[int64]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64Int32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64Int32V(rv2i(rv).(map[int64]int32), e)
 }
-func (_ fastpathT) EncMapInt64Int32V(v map[int64]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt64Int32V(v map[int64]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14994,43 +12517,40 @@ func (_ fastpathT) EncMapInt64Int32V(v map[int64]int32, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64Int64R(rv reflect.Value) {
-	fastpathTV.EncMapInt64Int64V(rv2i(rv).(map[int64]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64Int64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64Int64V(rv2i(rv).(map[int64]int64), e)
 }
-func (_ fastpathT) EncMapInt64Int64V(v map[int64]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt64Int64V(v map[int64]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -15040,43 +12560,40 @@ func (_ fastpathT) EncMapInt64Int64V(v map[int64]int64, checkNil bool, e *Encode
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[int64(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64Float32R(rv reflect.Value) {
-	fastpathTV.EncMapInt64Float32V(rv2i(rv).(map[int64]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64Float32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64Float32V(rv2i(rv).(map[int64]float32), e)
 }
-func (_ fastpathT) EncMapInt64Float32V(v map[int64]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt64Float32V(v map[int64]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -15086,43 +12603,40 @@ func (_ fastpathT) EncMapInt64Float32V(v map[int64]float32, checkNil bool, e *En
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[int64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64Float64R(rv reflect.Value) {
-	fastpathTV.EncMapInt64Float64V(rv2i(rv).(map[int64]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64Float64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64Float64V(rv2i(rv).(map[int64]float64), e)
 }
-func (_ fastpathT) EncMapInt64Float64V(v map[int64]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt64Float64V(v map[int64]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -15132,43 +12646,40 @@ func (_ fastpathT) EncMapInt64Float64V(v map[int64]float64, checkNil bool, e *En
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[int64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapInt64BoolR(rv reflect.Value) {
-	fastpathTV.EncMapInt64BoolV(rv2i(rv).(map[int64]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapInt64BoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapInt64BoolV(rv2i(rv).(map[int64]bool), e)
 }
-func (_ fastpathT) EncMapInt64BoolV(v map[int64]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapInt64BoolV(v map[int64]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -15178,43 +12689,40 @@ func (_ fastpathT) EncMapInt64BoolV(v map[int64]bool, checkNil bool, e *Encoder)
 		}
 		sort.Sort(intSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[int64(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolIntfR(rv reflect.Value) {
-	fastpathTV.EncMapBoolIntfV(rv2i(rv).(map[bool]interface{}), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolIntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolIntfV(rv2i(rv).(map[bool]interface{}), e)
 }
-func (_ fastpathT) EncMapBoolIntfV(v map[bool]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapBoolIntfV(v map[bool]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15224,43 +12732,40 @@ func (_ fastpathT) EncMapBoolIntfV(v map[bool]interface{}, checkNil bool, e *Enc
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[bool(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolStringR(rv reflect.Value) {
-	fastpathTV.EncMapBoolStringV(rv2i(rv).(map[bool]string), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolStringR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolStringV(rv2i(rv).(map[bool]string), e)
 }
-func (_ fastpathT) EncMapBoolStringV(v map[bool]string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapBoolStringV(v map[bool]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15270,43 +12775,40 @@ func (_ fastpathT) EncMapBoolStringV(v map[bool]string, checkNil bool, e *Encode
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v[bool(k2)])
+			ee.EncodeString(cUTF8, v[bool(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
-			ee.EncodeString(c_UTF8, v2)
+			ee.EncodeString(cUTF8, v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolUintR(rv reflect.Value) {
-	fastpathTV.EncMapBoolUintV(rv2i(rv).(map[bool]uint), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolUintR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolUintV(rv2i(rv).(map[bool]uint), e)
 }
-func (_ fastpathT) EncMapBoolUintV(v map[bool]uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapBoolUintV(v map[bool]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15316,43 +12818,40 @@ func (_ fastpathT) EncMapBoolUintV(v map[bool]uint, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[bool(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolUint8R(rv reflect.Value) {
-	fastpathTV.EncMapBoolUint8V(rv2i(rv).(map[bool]uint8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolUint8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolUint8V(rv2i(rv).(map[bool]uint8), e)
 }
-func (_ fastpathT) EncMapBoolUint8V(v map[bool]uint8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapBoolUint8V(v map[bool]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15362,43 +12861,40 @@ func (_ fastpathT) EncMapBoolUint8V(v map[bool]uint8, checkNil bool, e *Encoder)
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[bool(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolUint16R(rv reflect.Value) {
-	fastpathTV.EncMapBoolUint16V(rv2i(rv).(map[bool]uint16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolUint16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolUint16V(rv2i(rv).(map[bool]uint16), e)
 }
-func (_ fastpathT) EncMapBoolUint16V(v map[bool]uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapBoolUint16V(v map[bool]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15408,43 +12904,40 @@ func (_ fastpathT) EncMapBoolUint16V(v map[bool]uint16, checkNil bool, e *Encode
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[bool(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolUint32R(rv reflect.Value) {
-	fastpathTV.EncMapBoolUint32V(rv2i(rv).(map[bool]uint32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolUint32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolUint32V(rv2i(rv).(map[bool]uint32), e)
 }
-func (_ fastpathT) EncMapBoolUint32V(v map[bool]uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapBoolUint32V(v map[bool]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15454,43 +12947,40 @@ func (_ fastpathT) EncMapBoolUint32V(v map[bool]uint32, checkNil bool, e *Encode
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[bool(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolUint64R(rv reflect.Value) {
-	fastpathTV.EncMapBoolUint64V(rv2i(rv).(map[bool]uint64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolUint64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolUint64V(rv2i(rv).(map[bool]uint64), e)
 }
-func (_ fastpathT) EncMapBoolUint64V(v map[bool]uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapBoolUint64V(v map[bool]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15500,43 +12990,40 @@ func (_ fastpathT) EncMapBoolUint64V(v map[bool]uint64, checkNil bool, e *Encode
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v[bool(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeUint(uint64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolUintptrR(rv reflect.Value) {
-	fastpathTV.EncMapBoolUintptrV(rv2i(rv).(map[bool]uintptr), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolUintptrR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolUintptrV(rv2i(rv).(map[bool]uintptr), e)
 }
-func (_ fastpathT) EncMapBoolUintptrV(v map[bool]uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapBoolUintptrV(v map[bool]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15546,43 +13033,40 @@ func (_ fastpathT) EncMapBoolUintptrV(v map[bool]uintptr, checkNil bool, e *Enco
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v[bool(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			e.encode(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolIntR(rv reflect.Value) {
-	fastpathTV.EncMapBoolIntV(rv2i(rv).(map[bool]int), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolIntR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolIntV(rv2i(rv).(map[bool]int), e)
 }
-func (_ fastpathT) EncMapBoolIntV(v map[bool]int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapBoolIntV(v map[bool]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15592,43 +13076,40 @@ func (_ fastpathT) EncMapBoolIntV(v map[bool]int, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[bool(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolInt8R(rv reflect.Value) {
-	fastpathTV.EncMapBoolInt8V(rv2i(rv).(map[bool]int8), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolInt8R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolInt8V(rv2i(rv).(map[bool]int8), e)
 }
-func (_ fastpathT) EncMapBoolInt8V(v map[bool]int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapBoolInt8V(v map[bool]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15638,43 +13119,40 @@ func (_ fastpathT) EncMapBoolInt8V(v map[bool]int8, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[bool(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolInt16R(rv reflect.Value) {
-	fastpathTV.EncMapBoolInt16V(rv2i(rv).(map[bool]int16), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolInt16R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolInt16V(rv2i(rv).(map[bool]int16), e)
 }
-func (_ fastpathT) EncMapBoolInt16V(v map[bool]int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapBoolInt16V(v map[bool]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15684,43 +13162,40 @@ func (_ fastpathT) EncMapBoolInt16V(v map[bool]int16, checkNil bool, e *Encoder)
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[bool(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolInt32R(rv reflect.Value) {
-	fastpathTV.EncMapBoolInt32V(rv2i(rv).(map[bool]int32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolInt32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolInt32V(rv2i(rv).(map[bool]int32), e)
 }
-func (_ fastpathT) EncMapBoolInt32V(v map[bool]int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapBoolInt32V(v map[bool]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15730,43 +13205,40 @@ func (_ fastpathT) EncMapBoolInt32V(v map[bool]int32, checkNil bool, e *Encoder)
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[bool(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolInt64R(rv reflect.Value) {
-	fastpathTV.EncMapBoolInt64V(rv2i(rv).(map[bool]int64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolInt64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolInt64V(rv2i(rv).(map[bool]int64), e)
 }
-func (_ fastpathT) EncMapBoolInt64V(v map[bool]int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapBoolInt64V(v map[bool]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15776,43 +13248,40 @@ func (_ fastpathT) EncMapBoolInt64V(v map[bool]int64, checkNil bool, e *Encoder)
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v[bool(k2)]))
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeInt(int64(v2))
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolFloat32R(rv reflect.Value) {
-	fastpathTV.EncMapBoolFloat32V(rv2i(rv).(map[bool]float32), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolFloat32R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolFloat32V(rv2i(rv).(map[bool]float32), e)
 }
-func (_ fastpathT) EncMapBoolFloat32V(v map[bool]float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapBoolFloat32V(v map[bool]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15822,43 +13291,40 @@ func (_ fastpathT) EncMapBoolFloat32V(v map[bool]float32, checkNil bool, e *Enco
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v[bool(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat32(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolFloat64R(rv reflect.Value) {
-	fastpathTV.EncMapBoolFloat64V(rv2i(rv).(map[bool]float64), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolFloat64R(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolFloat64V(rv2i(rv).(map[bool]float64), e)
 }
-func (_ fastpathT) EncMapBoolFloat64V(v map[bool]float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapBoolFloat64V(v map[bool]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15868,43 +13334,40 @@ func (_ fastpathT) EncMapBoolFloat64V(v map[bool]float64, checkNil bool, e *Enco
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v[bool(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeFloat64(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
-func (f *encFnInfo) fastpathEncMapBoolBoolR(rv reflect.Value) {
-	fastpathTV.EncMapBoolBoolV(rv2i(rv).(map[bool]bool), fastpathCheckNilFalse, f.e)
+func (e *Encoder) fastpathEncMapBoolBoolR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapBoolBoolV(rv2i(rv).(map[bool]bool), e)
 }
-func (_ fastpathT) EncMapBoolBoolV(v map[bool]bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncMapBoolBoolV(v map[bool]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15914,2206 +13377,2821 @@ func (_ fastpathT) EncMapBoolBoolV(v map[bool]bool, checkNil bool, e *Encoder) {
 		}
 		sort.Sort(boolSlice(v2))
 		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v[bool(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+			if esep {
+				ee.WriteMapElemKey()
 			}
 			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+			if esep {
+				ee.WriteMapElemValue()
 			}
 			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
 // -- decode
 
 // -- -- fast path type switch
 func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool {
+	var changed bool
 	switch v := iv.(type) {
 
 	case []interface{}:
-		fastpathTV.DecSliceIntfV(v, fastpathCheckNilFalse, false, d)
+		var v2 []interface{}
+		v2, changed = fastpathTV.DecSliceIntfV(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	case *[]interface{}:
-		v2, changed2 := fastpathTV.DecSliceIntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 []interface{}
+		v2, changed = fastpathTV.DecSliceIntfV(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []string:
+		var v2 []string
+		v2, changed = fastpathTV.DecSliceStringV(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]string:
+		var v2 []string
+		v2, changed = fastpathTV.DecSliceStringV(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []float32:
+		var v2 []float32
+		v2, changed = fastpathTV.DecSliceFloat32V(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]float32:
+		var v2 []float32
+		v2, changed = fastpathTV.DecSliceFloat32V(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []float64:
+		var v2 []float64
+		v2, changed = fastpathTV.DecSliceFloat64V(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]float64:
+		var v2 []float64
+		v2, changed = fastpathTV.DecSliceFloat64V(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []uint:
+		var v2 []uint
+		v2, changed = fastpathTV.DecSliceUintV(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]uint:
+		var v2 []uint
+		v2, changed = fastpathTV.DecSliceUintV(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []uint16:
+		var v2 []uint16
+		v2, changed = fastpathTV.DecSliceUint16V(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]uint16:
+		var v2 []uint16
+		v2, changed = fastpathTV.DecSliceUint16V(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []uint32:
+		var v2 []uint32
+		v2, changed = fastpathTV.DecSliceUint32V(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]uint32:
+		var v2 []uint32
+		v2, changed = fastpathTV.DecSliceUint32V(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []uint64:
+		var v2 []uint64
+		v2, changed = fastpathTV.DecSliceUint64V(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]uint64:
+		var v2 []uint64
+		v2, changed = fastpathTV.DecSliceUint64V(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []uintptr:
+		var v2 []uintptr
+		v2, changed = fastpathTV.DecSliceUintptrV(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]uintptr:
+		var v2 []uintptr
+		v2, changed = fastpathTV.DecSliceUintptrV(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []int:
+		var v2 []int
+		v2, changed = fastpathTV.DecSliceIntV(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]int:
+		var v2 []int
+		v2, changed = fastpathTV.DecSliceIntV(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []int8:
+		var v2 []int8
+		v2, changed = fastpathTV.DecSliceInt8V(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]int8:
+		var v2 []int8
+		v2, changed = fastpathTV.DecSliceInt8V(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []int16:
+		var v2 []int16
+		v2, changed = fastpathTV.DecSliceInt16V(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]int16:
+		var v2 []int16
+		v2, changed = fastpathTV.DecSliceInt16V(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []int32:
+		var v2 []int32
+		v2, changed = fastpathTV.DecSliceInt32V(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]int32:
+		var v2 []int32
+		v2, changed = fastpathTV.DecSliceInt32V(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []int64:
+		var v2 []int64
+		v2, changed = fastpathTV.DecSliceInt64V(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]int64:
+		var v2 []int64
+		v2, changed = fastpathTV.DecSliceInt64V(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []bool:
+		var v2 []bool
+		v2, changed = fastpathTV.DecSliceBoolV(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]bool:
+		var v2 []bool
+		v2, changed = fastpathTV.DecSliceBoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
 
 	case map[interface{}]interface{}:
-		fastpathTV.DecMapIntfIntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfIntfV(v, false, d)
 	case *map[interface{}]interface{}:
-		v2, changed2 := fastpathTV.DecMapIntfIntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[interface{}]interface{}
+		v2, changed = fastpathTV.DecMapIntfIntfV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[interface{}]string:
-		fastpathTV.DecMapIntfStringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfStringV(v, false, d)
 	case *map[interface{}]string:
-		v2, changed2 := fastpathTV.DecMapIntfStringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[interface{}]string
+		v2, changed = fastpathTV.DecMapIntfStringV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[interface{}]uint:
-		fastpathTV.DecMapIntfUintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfUintV(v, false, d)
 	case *map[interface{}]uint:
-		v2, changed2 := fastpathTV.DecMapIntfUintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[interface{}]uint
+		v2, changed = fastpathTV.DecMapIntfUintV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[interface{}]uint8:
-		fastpathTV.DecMapIntfUint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfUint8V(v, false, d)
 	case *map[interface{}]uint8:
-		v2, changed2 := fastpathTV.DecMapIntfUint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[interface{}]uint8
+		v2, changed = fastpathTV.DecMapIntfUint8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[interface{}]uint16:
-		fastpathTV.DecMapIntfUint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfUint16V(v, false, d)
 	case *map[interface{}]uint16:
-		v2, changed2 := fastpathTV.DecMapIntfUint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[interface{}]uint16
+		v2, changed = fastpathTV.DecMapIntfUint16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[interface{}]uint32:
-		fastpathTV.DecMapIntfUint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfUint32V(v, false, d)
 	case *map[interface{}]uint32:
-		v2, changed2 := fastpathTV.DecMapIntfUint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[interface{}]uint32
+		v2, changed = fastpathTV.DecMapIntfUint32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[interface{}]uint64:
-		fastpathTV.DecMapIntfUint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfUint64V(v, false, d)
 	case *map[interface{}]uint64:
-		v2, changed2 := fastpathTV.DecMapIntfUint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[interface{}]uint64
+		v2, changed = fastpathTV.DecMapIntfUint64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[interface{}]uintptr:
-		fastpathTV.DecMapIntfUintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfUintptrV(v, false, d)
 	case *map[interface{}]uintptr:
-		v2, changed2 := fastpathTV.DecMapIntfUintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[interface{}]uintptr
+		v2, changed = fastpathTV.DecMapIntfUintptrV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[interface{}]int:
-		fastpathTV.DecMapIntfIntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfIntV(v, false, d)
 	case *map[interface{}]int:
-		v2, changed2 := fastpathTV.DecMapIntfIntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[interface{}]int
+		v2, changed = fastpathTV.DecMapIntfIntV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[interface{}]int8:
-		fastpathTV.DecMapIntfInt8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfInt8V(v, false, d)
 	case *map[interface{}]int8:
-		v2, changed2 := fastpathTV.DecMapIntfInt8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[interface{}]int8
+		v2, changed = fastpathTV.DecMapIntfInt8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[interface{}]int16:
-		fastpathTV.DecMapIntfInt16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfInt16V(v, false, d)
 	case *map[interface{}]int16:
-		v2, changed2 := fastpathTV.DecMapIntfInt16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[interface{}]int16
+		v2, changed = fastpathTV.DecMapIntfInt16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[interface{}]int32:
-		fastpathTV.DecMapIntfInt32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfInt32V(v, false, d)
 	case *map[interface{}]int32:
-		v2, changed2 := fastpathTV.DecMapIntfInt32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[interface{}]int32
+		v2, changed = fastpathTV.DecMapIntfInt32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[interface{}]int64:
-		fastpathTV.DecMapIntfInt64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfInt64V(v, false, d)
 	case *map[interface{}]int64:
-		v2, changed2 := fastpathTV.DecMapIntfInt64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[interface{}]int64
+		v2, changed = fastpathTV.DecMapIntfInt64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[interface{}]float32:
-		fastpathTV.DecMapIntfFloat32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfFloat32V(v, false, d)
 	case *map[interface{}]float32:
-		v2, changed2 := fastpathTV.DecMapIntfFloat32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[interface{}]float32
+		v2, changed = fastpathTV.DecMapIntfFloat32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[interface{}]float64:
-		fastpathTV.DecMapIntfFloat64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfFloat64V(v, false, d)
 	case *map[interface{}]float64:
-		v2, changed2 := fastpathTV.DecMapIntfFloat64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[interface{}]float64
+		v2, changed = fastpathTV.DecMapIntfFloat64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[interface{}]bool:
-		fastpathTV.DecMapIntfBoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntfBoolV(v, false, d)
 	case *map[interface{}]bool:
-		v2, changed2 := fastpathTV.DecMapIntfBoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[interface{}]bool
+		v2, changed = fastpathTV.DecMapIntfBoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []string:
-		fastpathTV.DecSliceStringV(v, fastpathCheckNilFalse, false, d)
-	case *[]string:
-		v2, changed2 := fastpathTV.DecSliceStringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
-			*v = v2
-		}
-
 	case map[string]interface{}:
-		fastpathTV.DecMapStringIntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringIntfV(v, false, d)
 	case *map[string]interface{}:
-		v2, changed2 := fastpathTV.DecMapStringIntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[string]interface{}
+		v2, changed = fastpathTV.DecMapStringIntfV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[string]string:
-		fastpathTV.DecMapStringStringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringStringV(v, false, d)
 	case *map[string]string:
-		v2, changed2 := fastpathTV.DecMapStringStringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[string]string
+		v2, changed = fastpathTV.DecMapStringStringV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[string]uint:
-		fastpathTV.DecMapStringUintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringUintV(v, false, d)
 	case *map[string]uint:
-		v2, changed2 := fastpathTV.DecMapStringUintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[string]uint
+		v2, changed = fastpathTV.DecMapStringUintV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[string]uint8:
-		fastpathTV.DecMapStringUint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringUint8V(v, false, d)
 	case *map[string]uint8:
-		v2, changed2 := fastpathTV.DecMapStringUint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[string]uint8
+		v2, changed = fastpathTV.DecMapStringUint8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[string]uint16:
-		fastpathTV.DecMapStringUint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringUint16V(v, false, d)
 	case *map[string]uint16:
-		v2, changed2 := fastpathTV.DecMapStringUint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[string]uint16
+		v2, changed = fastpathTV.DecMapStringUint16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[string]uint32:
-		fastpathTV.DecMapStringUint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringUint32V(v, false, d)
 	case *map[string]uint32:
-		v2, changed2 := fastpathTV.DecMapStringUint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[string]uint32
+		v2, changed = fastpathTV.DecMapStringUint32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[string]uint64:
-		fastpathTV.DecMapStringUint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringUint64V(v, false, d)
 	case *map[string]uint64:
-		v2, changed2 := fastpathTV.DecMapStringUint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[string]uint64
+		v2, changed = fastpathTV.DecMapStringUint64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[string]uintptr:
-		fastpathTV.DecMapStringUintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringUintptrV(v, false, d)
 	case *map[string]uintptr:
-		v2, changed2 := fastpathTV.DecMapStringUintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[string]uintptr
+		v2, changed = fastpathTV.DecMapStringUintptrV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[string]int:
-		fastpathTV.DecMapStringIntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringIntV(v, false, d)
 	case *map[string]int:
-		v2, changed2 := fastpathTV.DecMapStringIntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[string]int
+		v2, changed = fastpathTV.DecMapStringIntV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[string]int8:
-		fastpathTV.DecMapStringInt8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringInt8V(v, false, d)
 	case *map[string]int8:
-		v2, changed2 := fastpathTV.DecMapStringInt8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[string]int8
+		v2, changed = fastpathTV.DecMapStringInt8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[string]int16:
-		fastpathTV.DecMapStringInt16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringInt16V(v, false, d)
 	case *map[string]int16:
-		v2, changed2 := fastpathTV.DecMapStringInt16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[string]int16
+		v2, changed = fastpathTV.DecMapStringInt16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[string]int32:
-		fastpathTV.DecMapStringInt32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringInt32V(v, false, d)
 	case *map[string]int32:
-		v2, changed2 := fastpathTV.DecMapStringInt32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[string]int32
+		v2, changed = fastpathTV.DecMapStringInt32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[string]int64:
-		fastpathTV.DecMapStringInt64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringInt64V(v, false, d)
 	case *map[string]int64:
-		v2, changed2 := fastpathTV.DecMapStringInt64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[string]int64
+		v2, changed = fastpathTV.DecMapStringInt64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[string]float32:
-		fastpathTV.DecMapStringFloat32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringFloat32V(v, false, d)
 	case *map[string]float32:
-		v2, changed2 := fastpathTV.DecMapStringFloat32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[string]float32
+		v2, changed = fastpathTV.DecMapStringFloat32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[string]float64:
-		fastpathTV.DecMapStringFloat64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringFloat64V(v, false, d)
 	case *map[string]float64:
-		v2, changed2 := fastpathTV.DecMapStringFloat64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[string]float64
+		v2, changed = fastpathTV.DecMapStringFloat64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[string]bool:
-		fastpathTV.DecMapStringBoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapStringBoolV(v, false, d)
 	case *map[string]bool:
-		v2, changed2 := fastpathTV.DecMapStringBoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[string]bool
+		v2, changed = fastpathTV.DecMapStringBoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []float32:
-		fastpathTV.DecSliceFloat32V(v, fastpathCheckNilFalse, false, d)
-	case *[]float32:
-		v2, changed2 := fastpathTV.DecSliceFloat32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
-			*v = v2
-		}
-
 	case map[float32]interface{}:
-		fastpathTV.DecMapFloat32IntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32IntfV(v, false, d)
 	case *map[float32]interface{}:
-		v2, changed2 := fastpathTV.DecMapFloat32IntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float32]interface{}
+		v2, changed = fastpathTV.DecMapFloat32IntfV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float32]string:
-		fastpathTV.DecMapFloat32StringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32StringV(v, false, d)
 	case *map[float32]string:
-		v2, changed2 := fastpathTV.DecMapFloat32StringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float32]string
+		v2, changed = fastpathTV.DecMapFloat32StringV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float32]uint:
-		fastpathTV.DecMapFloat32UintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32UintV(v, false, d)
 	case *map[float32]uint:
-		v2, changed2 := fastpathTV.DecMapFloat32UintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float32]uint
+		v2, changed = fastpathTV.DecMapFloat32UintV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float32]uint8:
-		fastpathTV.DecMapFloat32Uint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32Uint8V(v, false, d)
 	case *map[float32]uint8:
-		v2, changed2 := fastpathTV.DecMapFloat32Uint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float32]uint8
+		v2, changed = fastpathTV.DecMapFloat32Uint8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float32]uint16:
-		fastpathTV.DecMapFloat32Uint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32Uint16V(v, false, d)
 	case *map[float32]uint16:
-		v2, changed2 := fastpathTV.DecMapFloat32Uint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float32]uint16
+		v2, changed = fastpathTV.DecMapFloat32Uint16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float32]uint32:
-		fastpathTV.DecMapFloat32Uint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32Uint32V(v, false, d)
 	case *map[float32]uint32:
-		v2, changed2 := fastpathTV.DecMapFloat32Uint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float32]uint32
+		v2, changed = fastpathTV.DecMapFloat32Uint32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float32]uint64:
-		fastpathTV.DecMapFloat32Uint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32Uint64V(v, false, d)
 	case *map[float32]uint64:
-		v2, changed2 := fastpathTV.DecMapFloat32Uint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float32]uint64
+		v2, changed = fastpathTV.DecMapFloat32Uint64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float32]uintptr:
-		fastpathTV.DecMapFloat32UintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32UintptrV(v, false, d)
 	case *map[float32]uintptr:
-		v2, changed2 := fastpathTV.DecMapFloat32UintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float32]uintptr
+		v2, changed = fastpathTV.DecMapFloat32UintptrV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float32]int:
-		fastpathTV.DecMapFloat32IntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32IntV(v, false, d)
 	case *map[float32]int:
-		v2, changed2 := fastpathTV.DecMapFloat32IntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float32]int
+		v2, changed = fastpathTV.DecMapFloat32IntV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float32]int8:
-		fastpathTV.DecMapFloat32Int8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32Int8V(v, false, d)
 	case *map[float32]int8:
-		v2, changed2 := fastpathTV.DecMapFloat32Int8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float32]int8
+		v2, changed = fastpathTV.DecMapFloat32Int8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float32]int16:
-		fastpathTV.DecMapFloat32Int16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32Int16V(v, false, d)
 	case *map[float32]int16:
-		v2, changed2 := fastpathTV.DecMapFloat32Int16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float32]int16
+		v2, changed = fastpathTV.DecMapFloat32Int16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float32]int32:
-		fastpathTV.DecMapFloat32Int32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32Int32V(v, false, d)
 	case *map[float32]int32:
-		v2, changed2 := fastpathTV.DecMapFloat32Int32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float32]int32
+		v2, changed = fastpathTV.DecMapFloat32Int32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float32]int64:
-		fastpathTV.DecMapFloat32Int64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32Int64V(v, false, d)
 	case *map[float32]int64:
-		v2, changed2 := fastpathTV.DecMapFloat32Int64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float32]int64
+		v2, changed = fastpathTV.DecMapFloat32Int64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float32]float32:
-		fastpathTV.DecMapFloat32Float32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32Float32V(v, false, d)
 	case *map[float32]float32:
-		v2, changed2 := fastpathTV.DecMapFloat32Float32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float32]float32
+		v2, changed = fastpathTV.DecMapFloat32Float32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float32]float64:
-		fastpathTV.DecMapFloat32Float64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32Float64V(v, false, d)
 	case *map[float32]float64:
-		v2, changed2 := fastpathTV.DecMapFloat32Float64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float32]float64
+		v2, changed = fastpathTV.DecMapFloat32Float64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float32]bool:
-		fastpathTV.DecMapFloat32BoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat32BoolV(v, false, d)
 	case *map[float32]bool:
-		v2, changed2 := fastpathTV.DecMapFloat32BoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float32]bool
+		v2, changed = fastpathTV.DecMapFloat32BoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []float64:
-		fastpathTV.DecSliceFloat64V(v, fastpathCheckNilFalse, false, d)
-	case *[]float64:
-		v2, changed2 := fastpathTV.DecSliceFloat64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
-			*v = v2
-		}
-
 	case map[float64]interface{}:
-		fastpathTV.DecMapFloat64IntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64IntfV(v, false, d)
 	case *map[float64]interface{}:
-		v2, changed2 := fastpathTV.DecMapFloat64IntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float64]interface{}
+		v2, changed = fastpathTV.DecMapFloat64IntfV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float64]string:
-		fastpathTV.DecMapFloat64StringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64StringV(v, false, d)
 	case *map[float64]string:
-		v2, changed2 := fastpathTV.DecMapFloat64StringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float64]string
+		v2, changed = fastpathTV.DecMapFloat64StringV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float64]uint:
-		fastpathTV.DecMapFloat64UintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64UintV(v, false, d)
 	case *map[float64]uint:
-		v2, changed2 := fastpathTV.DecMapFloat64UintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float64]uint
+		v2, changed = fastpathTV.DecMapFloat64UintV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float64]uint8:
-		fastpathTV.DecMapFloat64Uint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64Uint8V(v, false, d)
 	case *map[float64]uint8:
-		v2, changed2 := fastpathTV.DecMapFloat64Uint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float64]uint8
+		v2, changed = fastpathTV.DecMapFloat64Uint8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float64]uint16:
-		fastpathTV.DecMapFloat64Uint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64Uint16V(v, false, d)
 	case *map[float64]uint16:
-		v2, changed2 := fastpathTV.DecMapFloat64Uint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float64]uint16
+		v2, changed = fastpathTV.DecMapFloat64Uint16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float64]uint32:
-		fastpathTV.DecMapFloat64Uint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64Uint32V(v, false, d)
 	case *map[float64]uint32:
-		v2, changed2 := fastpathTV.DecMapFloat64Uint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float64]uint32
+		v2, changed = fastpathTV.DecMapFloat64Uint32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float64]uint64:
-		fastpathTV.DecMapFloat64Uint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64Uint64V(v, false, d)
 	case *map[float64]uint64:
-		v2, changed2 := fastpathTV.DecMapFloat64Uint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float64]uint64
+		v2, changed = fastpathTV.DecMapFloat64Uint64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float64]uintptr:
-		fastpathTV.DecMapFloat64UintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64UintptrV(v, false, d)
 	case *map[float64]uintptr:
-		v2, changed2 := fastpathTV.DecMapFloat64UintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float64]uintptr
+		v2, changed = fastpathTV.DecMapFloat64UintptrV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float64]int:
-		fastpathTV.DecMapFloat64IntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64IntV(v, false, d)
 	case *map[float64]int:
-		v2, changed2 := fastpathTV.DecMapFloat64IntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float64]int
+		v2, changed = fastpathTV.DecMapFloat64IntV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float64]int8:
-		fastpathTV.DecMapFloat64Int8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64Int8V(v, false, d)
 	case *map[float64]int8:
-		v2, changed2 := fastpathTV.DecMapFloat64Int8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float64]int8
+		v2, changed = fastpathTV.DecMapFloat64Int8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float64]int16:
-		fastpathTV.DecMapFloat64Int16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64Int16V(v, false, d)
 	case *map[float64]int16:
-		v2, changed2 := fastpathTV.DecMapFloat64Int16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float64]int16
+		v2, changed = fastpathTV.DecMapFloat64Int16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float64]int32:
-		fastpathTV.DecMapFloat64Int32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64Int32V(v, false, d)
 	case *map[float64]int32:
-		v2, changed2 := fastpathTV.DecMapFloat64Int32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float64]int32
+		v2, changed = fastpathTV.DecMapFloat64Int32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float64]int64:
-		fastpathTV.DecMapFloat64Int64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64Int64V(v, false, d)
 	case *map[float64]int64:
-		v2, changed2 := fastpathTV.DecMapFloat64Int64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float64]int64
+		v2, changed = fastpathTV.DecMapFloat64Int64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float64]float32:
-		fastpathTV.DecMapFloat64Float32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64Float32V(v, false, d)
 	case *map[float64]float32:
-		v2, changed2 := fastpathTV.DecMapFloat64Float32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float64]float32
+		v2, changed = fastpathTV.DecMapFloat64Float32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float64]float64:
-		fastpathTV.DecMapFloat64Float64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64Float64V(v, false, d)
 	case *map[float64]float64:
-		v2, changed2 := fastpathTV.DecMapFloat64Float64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float64]float64
+		v2, changed = fastpathTV.DecMapFloat64Float64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[float64]bool:
-		fastpathTV.DecMapFloat64BoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapFloat64BoolV(v, false, d)
 	case *map[float64]bool:
-		v2, changed2 := fastpathTV.DecMapFloat64BoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[float64]bool
+		v2, changed = fastpathTV.DecMapFloat64BoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []uint:
-		fastpathTV.DecSliceUintV(v, fastpathCheckNilFalse, false, d)
-	case *[]uint:
-		v2, changed2 := fastpathTV.DecSliceUintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
-			*v = v2
-		}
-
 	case map[uint]interface{}:
-		fastpathTV.DecMapUintIntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintIntfV(v, false, d)
 	case *map[uint]interface{}:
-		v2, changed2 := fastpathTV.DecMapUintIntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint]interface{}
+		v2, changed = fastpathTV.DecMapUintIntfV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint]string:
-		fastpathTV.DecMapUintStringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintStringV(v, false, d)
 	case *map[uint]string:
-		v2, changed2 := fastpathTV.DecMapUintStringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint]string
+		v2, changed = fastpathTV.DecMapUintStringV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint]uint:
-		fastpathTV.DecMapUintUintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintUintV(v, false, d)
 	case *map[uint]uint:
-		v2, changed2 := fastpathTV.DecMapUintUintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint]uint
+		v2, changed = fastpathTV.DecMapUintUintV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint]uint8:
-		fastpathTV.DecMapUintUint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintUint8V(v, false, d)
 	case *map[uint]uint8:
-		v2, changed2 := fastpathTV.DecMapUintUint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint]uint8
+		v2, changed = fastpathTV.DecMapUintUint8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint]uint16:
-		fastpathTV.DecMapUintUint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintUint16V(v, false, d)
 	case *map[uint]uint16:
-		v2, changed2 := fastpathTV.DecMapUintUint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint]uint16
+		v2, changed = fastpathTV.DecMapUintUint16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint]uint32:
-		fastpathTV.DecMapUintUint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintUint32V(v, false, d)
 	case *map[uint]uint32:
-		v2, changed2 := fastpathTV.DecMapUintUint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint]uint32
+		v2, changed = fastpathTV.DecMapUintUint32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint]uint64:
-		fastpathTV.DecMapUintUint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintUint64V(v, false, d)
 	case *map[uint]uint64:
-		v2, changed2 := fastpathTV.DecMapUintUint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint]uint64
+		v2, changed = fastpathTV.DecMapUintUint64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint]uintptr:
-		fastpathTV.DecMapUintUintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintUintptrV(v, false, d)
 	case *map[uint]uintptr:
-		v2, changed2 := fastpathTV.DecMapUintUintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint]uintptr
+		v2, changed = fastpathTV.DecMapUintUintptrV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint]int:
-		fastpathTV.DecMapUintIntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintIntV(v, false, d)
 	case *map[uint]int:
-		v2, changed2 := fastpathTV.DecMapUintIntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint]int
+		v2, changed = fastpathTV.DecMapUintIntV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint]int8:
-		fastpathTV.DecMapUintInt8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintInt8V(v, false, d)
 	case *map[uint]int8:
-		v2, changed2 := fastpathTV.DecMapUintInt8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint]int8
+		v2, changed = fastpathTV.DecMapUintInt8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint]int16:
-		fastpathTV.DecMapUintInt16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintInt16V(v, false, d)
 	case *map[uint]int16:
-		v2, changed2 := fastpathTV.DecMapUintInt16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint]int16
+		v2, changed = fastpathTV.DecMapUintInt16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint]int32:
-		fastpathTV.DecMapUintInt32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintInt32V(v, false, d)
 	case *map[uint]int32:
-		v2, changed2 := fastpathTV.DecMapUintInt32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint]int32
+		v2, changed = fastpathTV.DecMapUintInt32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint]int64:
-		fastpathTV.DecMapUintInt64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintInt64V(v, false, d)
 	case *map[uint]int64:
-		v2, changed2 := fastpathTV.DecMapUintInt64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint]int64
+		v2, changed = fastpathTV.DecMapUintInt64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint]float32:
-		fastpathTV.DecMapUintFloat32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintFloat32V(v, false, d)
 	case *map[uint]float32:
-		v2, changed2 := fastpathTV.DecMapUintFloat32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint]float32
+		v2, changed = fastpathTV.DecMapUintFloat32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint]float64:
-		fastpathTV.DecMapUintFloat64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintFloat64V(v, false, d)
 	case *map[uint]float64:
-		v2, changed2 := fastpathTV.DecMapUintFloat64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint]float64
+		v2, changed = fastpathTV.DecMapUintFloat64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint]bool:
-		fastpathTV.DecMapUintBoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintBoolV(v, false, d)
 	case *map[uint]bool:
-		v2, changed2 := fastpathTV.DecMapUintBoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint]bool
+		v2, changed = fastpathTV.DecMapUintBoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint8]interface{}:
-		fastpathTV.DecMapUint8IntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8IntfV(v, false, d)
 	case *map[uint8]interface{}:
-		v2, changed2 := fastpathTV.DecMapUint8IntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint8]interface{}
+		v2, changed = fastpathTV.DecMapUint8IntfV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint8]string:
-		fastpathTV.DecMapUint8StringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8StringV(v, false, d)
 	case *map[uint8]string:
-		v2, changed2 := fastpathTV.DecMapUint8StringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint8]string
+		v2, changed = fastpathTV.DecMapUint8StringV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint8]uint:
-		fastpathTV.DecMapUint8UintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8UintV(v, false, d)
 	case *map[uint8]uint:
-		v2, changed2 := fastpathTV.DecMapUint8UintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint8]uint
+		v2, changed = fastpathTV.DecMapUint8UintV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint8]uint8:
-		fastpathTV.DecMapUint8Uint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8Uint8V(v, false, d)
 	case *map[uint8]uint8:
-		v2, changed2 := fastpathTV.DecMapUint8Uint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint8]uint8
+		v2, changed = fastpathTV.DecMapUint8Uint8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint8]uint16:
-		fastpathTV.DecMapUint8Uint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8Uint16V(v, false, d)
 	case *map[uint8]uint16:
-		v2, changed2 := fastpathTV.DecMapUint8Uint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint8]uint16
+		v2, changed = fastpathTV.DecMapUint8Uint16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint8]uint32:
-		fastpathTV.DecMapUint8Uint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8Uint32V(v, false, d)
 	case *map[uint8]uint32:
-		v2, changed2 := fastpathTV.DecMapUint8Uint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint8]uint32
+		v2, changed = fastpathTV.DecMapUint8Uint32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint8]uint64:
-		fastpathTV.DecMapUint8Uint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8Uint64V(v, false, d)
 	case *map[uint8]uint64:
-		v2, changed2 := fastpathTV.DecMapUint8Uint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint8]uint64
+		v2, changed = fastpathTV.DecMapUint8Uint64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint8]uintptr:
-		fastpathTV.DecMapUint8UintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8UintptrV(v, false, d)
 	case *map[uint8]uintptr:
-		v2, changed2 := fastpathTV.DecMapUint8UintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint8]uintptr
+		v2, changed = fastpathTV.DecMapUint8UintptrV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint8]int:
-		fastpathTV.DecMapUint8IntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8IntV(v, false, d)
 	case *map[uint8]int:
-		v2, changed2 := fastpathTV.DecMapUint8IntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint8]int
+		v2, changed = fastpathTV.DecMapUint8IntV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint8]int8:
-		fastpathTV.DecMapUint8Int8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8Int8V(v, false, d)
 	case *map[uint8]int8:
-		v2, changed2 := fastpathTV.DecMapUint8Int8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint8]int8
+		v2, changed = fastpathTV.DecMapUint8Int8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint8]int16:
-		fastpathTV.DecMapUint8Int16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8Int16V(v, false, d)
 	case *map[uint8]int16:
-		v2, changed2 := fastpathTV.DecMapUint8Int16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint8]int16
+		v2, changed = fastpathTV.DecMapUint8Int16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint8]int32:
-		fastpathTV.DecMapUint8Int32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8Int32V(v, false, d)
 	case *map[uint8]int32:
-		v2, changed2 := fastpathTV.DecMapUint8Int32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint8]int32
+		v2, changed = fastpathTV.DecMapUint8Int32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint8]int64:
-		fastpathTV.DecMapUint8Int64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8Int64V(v, false, d)
 	case *map[uint8]int64:
-		v2, changed2 := fastpathTV.DecMapUint8Int64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint8]int64
+		v2, changed = fastpathTV.DecMapUint8Int64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint8]float32:
-		fastpathTV.DecMapUint8Float32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8Float32V(v, false, d)
 	case *map[uint8]float32:
-		v2, changed2 := fastpathTV.DecMapUint8Float32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint8]float32
+		v2, changed = fastpathTV.DecMapUint8Float32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint8]float64:
-		fastpathTV.DecMapUint8Float64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8Float64V(v, false, d)
 	case *map[uint8]float64:
-		v2, changed2 := fastpathTV.DecMapUint8Float64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint8]float64
+		v2, changed = fastpathTV.DecMapUint8Float64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint8]bool:
-		fastpathTV.DecMapUint8BoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint8BoolV(v, false, d)
 	case *map[uint8]bool:
-		v2, changed2 := fastpathTV.DecMapUint8BoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint8]bool
+		v2, changed = fastpathTV.DecMapUint8BoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []uint16:
-		fastpathTV.DecSliceUint16V(v, fastpathCheckNilFalse, false, d)
-	case *[]uint16:
-		v2, changed2 := fastpathTV.DecSliceUint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
-			*v = v2
-		}
-
 	case map[uint16]interface{}:
-		fastpathTV.DecMapUint16IntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16IntfV(v, false, d)
 	case *map[uint16]interface{}:
-		v2, changed2 := fastpathTV.DecMapUint16IntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint16]interface{}
+		v2, changed = fastpathTV.DecMapUint16IntfV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint16]string:
-		fastpathTV.DecMapUint16StringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16StringV(v, false, d)
 	case *map[uint16]string:
-		v2, changed2 := fastpathTV.DecMapUint16StringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint16]string
+		v2, changed = fastpathTV.DecMapUint16StringV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint16]uint:
-		fastpathTV.DecMapUint16UintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16UintV(v, false, d)
 	case *map[uint16]uint:
-		v2, changed2 := fastpathTV.DecMapUint16UintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint16]uint
+		v2, changed = fastpathTV.DecMapUint16UintV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint16]uint8:
-		fastpathTV.DecMapUint16Uint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16Uint8V(v, false, d)
 	case *map[uint16]uint8:
-		v2, changed2 := fastpathTV.DecMapUint16Uint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint16]uint8
+		v2, changed = fastpathTV.DecMapUint16Uint8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint16]uint16:
-		fastpathTV.DecMapUint16Uint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16Uint16V(v, false, d)
 	case *map[uint16]uint16:
-		v2, changed2 := fastpathTV.DecMapUint16Uint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint16]uint16
+		v2, changed = fastpathTV.DecMapUint16Uint16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint16]uint32:
-		fastpathTV.DecMapUint16Uint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16Uint32V(v, false, d)
 	case *map[uint16]uint32:
-		v2, changed2 := fastpathTV.DecMapUint16Uint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint16]uint32
+		v2, changed = fastpathTV.DecMapUint16Uint32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint16]uint64:
-		fastpathTV.DecMapUint16Uint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16Uint64V(v, false, d)
 	case *map[uint16]uint64:
-		v2, changed2 := fastpathTV.DecMapUint16Uint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint16]uint64
+		v2, changed = fastpathTV.DecMapUint16Uint64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint16]uintptr:
-		fastpathTV.DecMapUint16UintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16UintptrV(v, false, d)
 	case *map[uint16]uintptr:
-		v2, changed2 := fastpathTV.DecMapUint16UintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint16]uintptr
+		v2, changed = fastpathTV.DecMapUint16UintptrV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint16]int:
-		fastpathTV.DecMapUint16IntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16IntV(v, false, d)
 	case *map[uint16]int:
-		v2, changed2 := fastpathTV.DecMapUint16IntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint16]int
+		v2, changed = fastpathTV.DecMapUint16IntV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint16]int8:
-		fastpathTV.DecMapUint16Int8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16Int8V(v, false, d)
 	case *map[uint16]int8:
-		v2, changed2 := fastpathTV.DecMapUint16Int8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint16]int8
+		v2, changed = fastpathTV.DecMapUint16Int8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint16]int16:
-		fastpathTV.DecMapUint16Int16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16Int16V(v, false, d)
 	case *map[uint16]int16:
-		v2, changed2 := fastpathTV.DecMapUint16Int16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint16]int16
+		v2, changed = fastpathTV.DecMapUint16Int16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint16]int32:
-		fastpathTV.DecMapUint16Int32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16Int32V(v, false, d)
 	case *map[uint16]int32:
-		v2, changed2 := fastpathTV.DecMapUint16Int32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint16]int32
+		v2, changed = fastpathTV.DecMapUint16Int32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint16]int64:
-		fastpathTV.DecMapUint16Int64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16Int64V(v, false, d)
 	case *map[uint16]int64:
-		v2, changed2 := fastpathTV.DecMapUint16Int64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint16]int64
+		v2, changed = fastpathTV.DecMapUint16Int64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint16]float32:
-		fastpathTV.DecMapUint16Float32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16Float32V(v, false, d)
 	case *map[uint16]float32:
-		v2, changed2 := fastpathTV.DecMapUint16Float32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint16]float32
+		v2, changed = fastpathTV.DecMapUint16Float32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint16]float64:
-		fastpathTV.DecMapUint16Float64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16Float64V(v, false, d)
 	case *map[uint16]float64:
-		v2, changed2 := fastpathTV.DecMapUint16Float64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint16]float64
+		v2, changed = fastpathTV.DecMapUint16Float64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint16]bool:
-		fastpathTV.DecMapUint16BoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint16BoolV(v, false, d)
 	case *map[uint16]bool:
-		v2, changed2 := fastpathTV.DecMapUint16BoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint16]bool
+		v2, changed = fastpathTV.DecMapUint16BoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []uint32:
-		fastpathTV.DecSliceUint32V(v, fastpathCheckNilFalse, false, d)
-	case *[]uint32:
-		v2, changed2 := fastpathTV.DecSliceUint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
-			*v = v2
-		}
-
 	case map[uint32]interface{}:
-		fastpathTV.DecMapUint32IntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32IntfV(v, false, d)
 	case *map[uint32]interface{}:
-		v2, changed2 := fastpathTV.DecMapUint32IntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint32]interface{}
+		v2, changed = fastpathTV.DecMapUint32IntfV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint32]string:
-		fastpathTV.DecMapUint32StringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32StringV(v, false, d)
 	case *map[uint32]string:
-		v2, changed2 := fastpathTV.DecMapUint32StringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint32]string
+		v2, changed = fastpathTV.DecMapUint32StringV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint32]uint:
-		fastpathTV.DecMapUint32UintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32UintV(v, false, d)
 	case *map[uint32]uint:
-		v2, changed2 := fastpathTV.DecMapUint32UintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint32]uint
+		v2, changed = fastpathTV.DecMapUint32UintV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint32]uint8:
-		fastpathTV.DecMapUint32Uint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32Uint8V(v, false, d)
 	case *map[uint32]uint8:
-		v2, changed2 := fastpathTV.DecMapUint32Uint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint32]uint8
+		v2, changed = fastpathTV.DecMapUint32Uint8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint32]uint16:
-		fastpathTV.DecMapUint32Uint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32Uint16V(v, false, d)
 	case *map[uint32]uint16:
-		v2, changed2 := fastpathTV.DecMapUint32Uint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint32]uint16
+		v2, changed = fastpathTV.DecMapUint32Uint16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint32]uint32:
-		fastpathTV.DecMapUint32Uint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32Uint32V(v, false, d)
 	case *map[uint32]uint32:
-		v2, changed2 := fastpathTV.DecMapUint32Uint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint32]uint32
+		v2, changed = fastpathTV.DecMapUint32Uint32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint32]uint64:
-		fastpathTV.DecMapUint32Uint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32Uint64V(v, false, d)
 	case *map[uint32]uint64:
-		v2, changed2 := fastpathTV.DecMapUint32Uint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint32]uint64
+		v2, changed = fastpathTV.DecMapUint32Uint64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint32]uintptr:
-		fastpathTV.DecMapUint32UintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32UintptrV(v, false, d)
 	case *map[uint32]uintptr:
-		v2, changed2 := fastpathTV.DecMapUint32UintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint32]uintptr
+		v2, changed = fastpathTV.DecMapUint32UintptrV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint32]int:
-		fastpathTV.DecMapUint32IntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32IntV(v, false, d)
 	case *map[uint32]int:
-		v2, changed2 := fastpathTV.DecMapUint32IntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint32]int
+		v2, changed = fastpathTV.DecMapUint32IntV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint32]int8:
-		fastpathTV.DecMapUint32Int8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32Int8V(v, false, d)
 	case *map[uint32]int8:
-		v2, changed2 := fastpathTV.DecMapUint32Int8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint32]int8
+		v2, changed = fastpathTV.DecMapUint32Int8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint32]int16:
-		fastpathTV.DecMapUint32Int16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32Int16V(v, false, d)
 	case *map[uint32]int16:
-		v2, changed2 := fastpathTV.DecMapUint32Int16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint32]int16
+		v2, changed = fastpathTV.DecMapUint32Int16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint32]int32:
-		fastpathTV.DecMapUint32Int32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32Int32V(v, false, d)
 	case *map[uint32]int32:
-		v2, changed2 := fastpathTV.DecMapUint32Int32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint32]int32
+		v2, changed = fastpathTV.DecMapUint32Int32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint32]int64:
-		fastpathTV.DecMapUint32Int64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32Int64V(v, false, d)
 	case *map[uint32]int64:
-		v2, changed2 := fastpathTV.DecMapUint32Int64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint32]int64
+		v2, changed = fastpathTV.DecMapUint32Int64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint32]float32:
-		fastpathTV.DecMapUint32Float32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32Float32V(v, false, d)
 	case *map[uint32]float32:
-		v2, changed2 := fastpathTV.DecMapUint32Float32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint32]float32
+		v2, changed = fastpathTV.DecMapUint32Float32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint32]float64:
-		fastpathTV.DecMapUint32Float64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32Float64V(v, false, d)
 	case *map[uint32]float64:
-		v2, changed2 := fastpathTV.DecMapUint32Float64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint32]float64
+		v2, changed = fastpathTV.DecMapUint32Float64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint32]bool:
-		fastpathTV.DecMapUint32BoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint32BoolV(v, false, d)
 	case *map[uint32]bool:
-		v2, changed2 := fastpathTV.DecMapUint32BoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint32]bool
+		v2, changed = fastpathTV.DecMapUint32BoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []uint64:
-		fastpathTV.DecSliceUint64V(v, fastpathCheckNilFalse, false, d)
-	case *[]uint64:
-		v2, changed2 := fastpathTV.DecSliceUint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
-			*v = v2
-		}
-
 	case map[uint64]interface{}:
-		fastpathTV.DecMapUint64IntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64IntfV(v, false, d)
 	case *map[uint64]interface{}:
-		v2, changed2 := fastpathTV.DecMapUint64IntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint64]interface{}
+		v2, changed = fastpathTV.DecMapUint64IntfV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint64]string:
-		fastpathTV.DecMapUint64StringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64StringV(v, false, d)
 	case *map[uint64]string:
-		v2, changed2 := fastpathTV.DecMapUint64StringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint64]string
+		v2, changed = fastpathTV.DecMapUint64StringV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint64]uint:
-		fastpathTV.DecMapUint64UintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64UintV(v, false, d)
 	case *map[uint64]uint:
-		v2, changed2 := fastpathTV.DecMapUint64UintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint64]uint
+		v2, changed = fastpathTV.DecMapUint64UintV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint64]uint8:
-		fastpathTV.DecMapUint64Uint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64Uint8V(v, false, d)
 	case *map[uint64]uint8:
-		v2, changed2 := fastpathTV.DecMapUint64Uint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint64]uint8
+		v2, changed = fastpathTV.DecMapUint64Uint8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint64]uint16:
-		fastpathTV.DecMapUint64Uint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64Uint16V(v, false, d)
 	case *map[uint64]uint16:
-		v2, changed2 := fastpathTV.DecMapUint64Uint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint64]uint16
+		v2, changed = fastpathTV.DecMapUint64Uint16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint64]uint32:
-		fastpathTV.DecMapUint64Uint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64Uint32V(v, false, d)
 	case *map[uint64]uint32:
-		v2, changed2 := fastpathTV.DecMapUint64Uint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint64]uint32
+		v2, changed = fastpathTV.DecMapUint64Uint32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint64]uint64:
-		fastpathTV.DecMapUint64Uint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64Uint64V(v, false, d)
 	case *map[uint64]uint64:
-		v2, changed2 := fastpathTV.DecMapUint64Uint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint64]uint64
+		v2, changed = fastpathTV.DecMapUint64Uint64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint64]uintptr:
-		fastpathTV.DecMapUint64UintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64UintptrV(v, false, d)
 	case *map[uint64]uintptr:
-		v2, changed2 := fastpathTV.DecMapUint64UintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint64]uintptr
+		v2, changed = fastpathTV.DecMapUint64UintptrV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint64]int:
-		fastpathTV.DecMapUint64IntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64IntV(v, false, d)
 	case *map[uint64]int:
-		v2, changed2 := fastpathTV.DecMapUint64IntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint64]int
+		v2, changed = fastpathTV.DecMapUint64IntV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint64]int8:
-		fastpathTV.DecMapUint64Int8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64Int8V(v, false, d)
 	case *map[uint64]int8:
-		v2, changed2 := fastpathTV.DecMapUint64Int8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint64]int8
+		v2, changed = fastpathTV.DecMapUint64Int8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint64]int16:
-		fastpathTV.DecMapUint64Int16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64Int16V(v, false, d)
 	case *map[uint64]int16:
-		v2, changed2 := fastpathTV.DecMapUint64Int16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint64]int16
+		v2, changed = fastpathTV.DecMapUint64Int16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint64]int32:
-		fastpathTV.DecMapUint64Int32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64Int32V(v, false, d)
 	case *map[uint64]int32:
-		v2, changed2 := fastpathTV.DecMapUint64Int32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint64]int32
+		v2, changed = fastpathTV.DecMapUint64Int32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint64]int64:
-		fastpathTV.DecMapUint64Int64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64Int64V(v, false, d)
 	case *map[uint64]int64:
-		v2, changed2 := fastpathTV.DecMapUint64Int64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint64]int64
+		v2, changed = fastpathTV.DecMapUint64Int64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint64]float32:
-		fastpathTV.DecMapUint64Float32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64Float32V(v, false, d)
 	case *map[uint64]float32:
-		v2, changed2 := fastpathTV.DecMapUint64Float32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint64]float32
+		v2, changed = fastpathTV.DecMapUint64Float32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint64]float64:
-		fastpathTV.DecMapUint64Float64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64Float64V(v, false, d)
 	case *map[uint64]float64:
-		v2, changed2 := fastpathTV.DecMapUint64Float64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint64]float64
+		v2, changed = fastpathTV.DecMapUint64Float64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uint64]bool:
-		fastpathTV.DecMapUint64BoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUint64BoolV(v, false, d)
 	case *map[uint64]bool:
-		v2, changed2 := fastpathTV.DecMapUint64BoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uint64]bool
+		v2, changed = fastpathTV.DecMapUint64BoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []uintptr:
-		fastpathTV.DecSliceUintptrV(v, fastpathCheckNilFalse, false, d)
-	case *[]uintptr:
-		v2, changed2 := fastpathTV.DecSliceUintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
-			*v = v2
-		}
-
 	case map[uintptr]interface{}:
-		fastpathTV.DecMapUintptrIntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrIntfV(v, false, d)
 	case *map[uintptr]interface{}:
-		v2, changed2 := fastpathTV.DecMapUintptrIntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uintptr]interface{}
+		v2, changed = fastpathTV.DecMapUintptrIntfV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uintptr]string:
-		fastpathTV.DecMapUintptrStringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrStringV(v, false, d)
 	case *map[uintptr]string:
-		v2, changed2 := fastpathTV.DecMapUintptrStringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uintptr]string
+		v2, changed = fastpathTV.DecMapUintptrStringV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uintptr]uint:
-		fastpathTV.DecMapUintptrUintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrUintV(v, false, d)
 	case *map[uintptr]uint:
-		v2, changed2 := fastpathTV.DecMapUintptrUintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uintptr]uint
+		v2, changed = fastpathTV.DecMapUintptrUintV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uintptr]uint8:
-		fastpathTV.DecMapUintptrUint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrUint8V(v, false, d)
 	case *map[uintptr]uint8:
-		v2, changed2 := fastpathTV.DecMapUintptrUint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uintptr]uint8
+		v2, changed = fastpathTV.DecMapUintptrUint8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uintptr]uint16:
-		fastpathTV.DecMapUintptrUint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrUint16V(v, false, d)
 	case *map[uintptr]uint16:
-		v2, changed2 := fastpathTV.DecMapUintptrUint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uintptr]uint16
+		v2, changed = fastpathTV.DecMapUintptrUint16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uintptr]uint32:
-		fastpathTV.DecMapUintptrUint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrUint32V(v, false, d)
 	case *map[uintptr]uint32:
-		v2, changed2 := fastpathTV.DecMapUintptrUint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uintptr]uint32
+		v2, changed = fastpathTV.DecMapUintptrUint32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uintptr]uint64:
-		fastpathTV.DecMapUintptrUint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrUint64V(v, false, d)
 	case *map[uintptr]uint64:
-		v2, changed2 := fastpathTV.DecMapUintptrUint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uintptr]uint64
+		v2, changed = fastpathTV.DecMapUintptrUint64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uintptr]uintptr:
-		fastpathTV.DecMapUintptrUintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrUintptrV(v, false, d)
 	case *map[uintptr]uintptr:
-		v2, changed2 := fastpathTV.DecMapUintptrUintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uintptr]uintptr
+		v2, changed = fastpathTV.DecMapUintptrUintptrV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uintptr]int:
-		fastpathTV.DecMapUintptrIntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrIntV(v, false, d)
 	case *map[uintptr]int:
-		v2, changed2 := fastpathTV.DecMapUintptrIntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uintptr]int
+		v2, changed = fastpathTV.DecMapUintptrIntV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uintptr]int8:
-		fastpathTV.DecMapUintptrInt8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrInt8V(v, false, d)
 	case *map[uintptr]int8:
-		v2, changed2 := fastpathTV.DecMapUintptrInt8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uintptr]int8
+		v2, changed = fastpathTV.DecMapUintptrInt8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uintptr]int16:
-		fastpathTV.DecMapUintptrInt16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrInt16V(v, false, d)
 	case *map[uintptr]int16:
-		v2, changed2 := fastpathTV.DecMapUintptrInt16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uintptr]int16
+		v2, changed = fastpathTV.DecMapUintptrInt16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uintptr]int32:
-		fastpathTV.DecMapUintptrInt32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrInt32V(v, false, d)
 	case *map[uintptr]int32:
-		v2, changed2 := fastpathTV.DecMapUintptrInt32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uintptr]int32
+		v2, changed = fastpathTV.DecMapUintptrInt32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uintptr]int64:
-		fastpathTV.DecMapUintptrInt64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrInt64V(v, false, d)
 	case *map[uintptr]int64:
-		v2, changed2 := fastpathTV.DecMapUintptrInt64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uintptr]int64
+		v2, changed = fastpathTV.DecMapUintptrInt64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uintptr]float32:
-		fastpathTV.DecMapUintptrFloat32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrFloat32V(v, false, d)
 	case *map[uintptr]float32:
-		v2, changed2 := fastpathTV.DecMapUintptrFloat32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uintptr]float32
+		v2, changed = fastpathTV.DecMapUintptrFloat32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uintptr]float64:
-		fastpathTV.DecMapUintptrFloat64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrFloat64V(v, false, d)
 	case *map[uintptr]float64:
-		v2, changed2 := fastpathTV.DecMapUintptrFloat64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uintptr]float64
+		v2, changed = fastpathTV.DecMapUintptrFloat64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[uintptr]bool:
-		fastpathTV.DecMapUintptrBoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapUintptrBoolV(v, false, d)
 	case *map[uintptr]bool:
-		v2, changed2 := fastpathTV.DecMapUintptrBoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[uintptr]bool
+		v2, changed = fastpathTV.DecMapUintptrBoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []int:
-		fastpathTV.DecSliceIntV(v, fastpathCheckNilFalse, false, d)
-	case *[]int:
-		v2, changed2 := fastpathTV.DecSliceIntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
-			*v = v2
-		}
-
 	case map[int]interface{}:
-		fastpathTV.DecMapIntIntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntIntfV(v, false, d)
 	case *map[int]interface{}:
-		v2, changed2 := fastpathTV.DecMapIntIntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int]interface{}
+		v2, changed = fastpathTV.DecMapIntIntfV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int]string:
-		fastpathTV.DecMapIntStringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntStringV(v, false, d)
 	case *map[int]string:
-		v2, changed2 := fastpathTV.DecMapIntStringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int]string
+		v2, changed = fastpathTV.DecMapIntStringV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int]uint:
-		fastpathTV.DecMapIntUintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntUintV(v, false, d)
 	case *map[int]uint:
-		v2, changed2 := fastpathTV.DecMapIntUintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int]uint
+		v2, changed = fastpathTV.DecMapIntUintV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int]uint8:
-		fastpathTV.DecMapIntUint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntUint8V(v, false, d)
 	case *map[int]uint8:
-		v2, changed2 := fastpathTV.DecMapIntUint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int]uint8
+		v2, changed = fastpathTV.DecMapIntUint8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int]uint16:
-		fastpathTV.DecMapIntUint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntUint16V(v, false, d)
 	case *map[int]uint16:
-		v2, changed2 := fastpathTV.DecMapIntUint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int]uint16
+		v2, changed = fastpathTV.DecMapIntUint16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int]uint32:
-		fastpathTV.DecMapIntUint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntUint32V(v, false, d)
 	case *map[int]uint32:
-		v2, changed2 := fastpathTV.DecMapIntUint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int]uint32
+		v2, changed = fastpathTV.DecMapIntUint32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int]uint64:
-		fastpathTV.DecMapIntUint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntUint64V(v, false, d)
 	case *map[int]uint64:
-		v2, changed2 := fastpathTV.DecMapIntUint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int]uint64
+		v2, changed = fastpathTV.DecMapIntUint64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int]uintptr:
-		fastpathTV.DecMapIntUintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntUintptrV(v, false, d)
 	case *map[int]uintptr:
-		v2, changed2 := fastpathTV.DecMapIntUintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int]uintptr
+		v2, changed = fastpathTV.DecMapIntUintptrV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int]int:
-		fastpathTV.DecMapIntIntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntIntV(v, false, d)
 	case *map[int]int:
-		v2, changed2 := fastpathTV.DecMapIntIntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int]int
+		v2, changed = fastpathTV.DecMapIntIntV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int]int8:
-		fastpathTV.DecMapIntInt8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntInt8V(v, false, d)
 	case *map[int]int8:
-		v2, changed2 := fastpathTV.DecMapIntInt8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int]int8
+		v2, changed = fastpathTV.DecMapIntInt8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int]int16:
-		fastpathTV.DecMapIntInt16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntInt16V(v, false, d)
 	case *map[int]int16:
-		v2, changed2 := fastpathTV.DecMapIntInt16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int]int16
+		v2, changed = fastpathTV.DecMapIntInt16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int]int32:
-		fastpathTV.DecMapIntInt32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntInt32V(v, false, d)
 	case *map[int]int32:
-		v2, changed2 := fastpathTV.DecMapIntInt32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int]int32
+		v2, changed = fastpathTV.DecMapIntInt32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int]int64:
-		fastpathTV.DecMapIntInt64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntInt64V(v, false, d)
 	case *map[int]int64:
-		v2, changed2 := fastpathTV.DecMapIntInt64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int]int64
+		v2, changed = fastpathTV.DecMapIntInt64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int]float32:
-		fastpathTV.DecMapIntFloat32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntFloat32V(v, false, d)
 	case *map[int]float32:
-		v2, changed2 := fastpathTV.DecMapIntFloat32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int]float32
+		v2, changed = fastpathTV.DecMapIntFloat32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int]float64:
-		fastpathTV.DecMapIntFloat64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntFloat64V(v, false, d)
 	case *map[int]float64:
-		v2, changed2 := fastpathTV.DecMapIntFloat64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int]float64
+		v2, changed = fastpathTV.DecMapIntFloat64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int]bool:
-		fastpathTV.DecMapIntBoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapIntBoolV(v, false, d)
 	case *map[int]bool:
-		v2, changed2 := fastpathTV.DecMapIntBoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int]bool
+		v2, changed = fastpathTV.DecMapIntBoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []int8:
-		fastpathTV.DecSliceInt8V(v, fastpathCheckNilFalse, false, d)
-	case *[]int8:
-		v2, changed2 := fastpathTV.DecSliceInt8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
-			*v = v2
-		}
-
 	case map[int8]interface{}:
-		fastpathTV.DecMapInt8IntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8IntfV(v, false, d)
 	case *map[int8]interface{}:
-		v2, changed2 := fastpathTV.DecMapInt8IntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int8]interface{}
+		v2, changed = fastpathTV.DecMapInt8IntfV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int8]string:
-		fastpathTV.DecMapInt8StringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8StringV(v, false, d)
 	case *map[int8]string:
-		v2, changed2 := fastpathTV.DecMapInt8StringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int8]string
+		v2, changed = fastpathTV.DecMapInt8StringV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int8]uint:
-		fastpathTV.DecMapInt8UintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8UintV(v, false, d)
 	case *map[int8]uint:
-		v2, changed2 := fastpathTV.DecMapInt8UintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int8]uint
+		v2, changed = fastpathTV.DecMapInt8UintV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int8]uint8:
-		fastpathTV.DecMapInt8Uint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8Uint8V(v, false, d)
 	case *map[int8]uint8:
-		v2, changed2 := fastpathTV.DecMapInt8Uint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int8]uint8
+		v2, changed = fastpathTV.DecMapInt8Uint8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int8]uint16:
-		fastpathTV.DecMapInt8Uint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8Uint16V(v, false, d)
 	case *map[int8]uint16:
-		v2, changed2 := fastpathTV.DecMapInt8Uint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int8]uint16
+		v2, changed = fastpathTV.DecMapInt8Uint16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int8]uint32:
-		fastpathTV.DecMapInt8Uint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8Uint32V(v, false, d)
 	case *map[int8]uint32:
-		v2, changed2 := fastpathTV.DecMapInt8Uint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int8]uint32
+		v2, changed = fastpathTV.DecMapInt8Uint32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int8]uint64:
-		fastpathTV.DecMapInt8Uint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8Uint64V(v, false, d)
 	case *map[int8]uint64:
-		v2, changed2 := fastpathTV.DecMapInt8Uint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int8]uint64
+		v2, changed = fastpathTV.DecMapInt8Uint64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int8]uintptr:
-		fastpathTV.DecMapInt8UintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8UintptrV(v, false, d)
 	case *map[int8]uintptr:
-		v2, changed2 := fastpathTV.DecMapInt8UintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int8]uintptr
+		v2, changed = fastpathTV.DecMapInt8UintptrV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int8]int:
-		fastpathTV.DecMapInt8IntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8IntV(v, false, d)
 	case *map[int8]int:
-		v2, changed2 := fastpathTV.DecMapInt8IntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int8]int
+		v2, changed = fastpathTV.DecMapInt8IntV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int8]int8:
-		fastpathTV.DecMapInt8Int8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8Int8V(v, false, d)
 	case *map[int8]int8:
-		v2, changed2 := fastpathTV.DecMapInt8Int8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int8]int8
+		v2, changed = fastpathTV.DecMapInt8Int8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int8]int16:
-		fastpathTV.DecMapInt8Int16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8Int16V(v, false, d)
 	case *map[int8]int16:
-		v2, changed2 := fastpathTV.DecMapInt8Int16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int8]int16
+		v2, changed = fastpathTV.DecMapInt8Int16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int8]int32:
-		fastpathTV.DecMapInt8Int32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8Int32V(v, false, d)
 	case *map[int8]int32:
-		v2, changed2 := fastpathTV.DecMapInt8Int32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int8]int32
+		v2, changed = fastpathTV.DecMapInt8Int32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int8]int64:
-		fastpathTV.DecMapInt8Int64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8Int64V(v, false, d)
 	case *map[int8]int64:
-		v2, changed2 := fastpathTV.DecMapInt8Int64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int8]int64
+		v2, changed = fastpathTV.DecMapInt8Int64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int8]float32:
-		fastpathTV.DecMapInt8Float32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8Float32V(v, false, d)
 	case *map[int8]float32:
-		v2, changed2 := fastpathTV.DecMapInt8Float32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int8]float32
+		v2, changed = fastpathTV.DecMapInt8Float32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int8]float64:
-		fastpathTV.DecMapInt8Float64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8Float64V(v, false, d)
 	case *map[int8]float64:
-		v2, changed2 := fastpathTV.DecMapInt8Float64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int8]float64
+		v2, changed = fastpathTV.DecMapInt8Float64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int8]bool:
-		fastpathTV.DecMapInt8BoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt8BoolV(v, false, d)
 	case *map[int8]bool:
-		v2, changed2 := fastpathTV.DecMapInt8BoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int8]bool
+		v2, changed = fastpathTV.DecMapInt8BoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []int16:
-		fastpathTV.DecSliceInt16V(v, fastpathCheckNilFalse, false, d)
-	case *[]int16:
-		v2, changed2 := fastpathTV.DecSliceInt16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
-			*v = v2
-		}
-
 	case map[int16]interface{}:
-		fastpathTV.DecMapInt16IntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16IntfV(v, false, d)
 	case *map[int16]interface{}:
-		v2, changed2 := fastpathTV.DecMapInt16IntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int16]interface{}
+		v2, changed = fastpathTV.DecMapInt16IntfV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int16]string:
-		fastpathTV.DecMapInt16StringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16StringV(v, false, d)
 	case *map[int16]string:
-		v2, changed2 := fastpathTV.DecMapInt16StringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int16]string
+		v2, changed = fastpathTV.DecMapInt16StringV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int16]uint:
-		fastpathTV.DecMapInt16UintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16UintV(v, false, d)
 	case *map[int16]uint:
-		v2, changed2 := fastpathTV.DecMapInt16UintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int16]uint
+		v2, changed = fastpathTV.DecMapInt16UintV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int16]uint8:
-		fastpathTV.DecMapInt16Uint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16Uint8V(v, false, d)
 	case *map[int16]uint8:
-		v2, changed2 := fastpathTV.DecMapInt16Uint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int16]uint8
+		v2, changed = fastpathTV.DecMapInt16Uint8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int16]uint16:
-		fastpathTV.DecMapInt16Uint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16Uint16V(v, false, d)
 	case *map[int16]uint16:
-		v2, changed2 := fastpathTV.DecMapInt16Uint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int16]uint16
+		v2, changed = fastpathTV.DecMapInt16Uint16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int16]uint32:
-		fastpathTV.DecMapInt16Uint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16Uint32V(v, false, d)
 	case *map[int16]uint32:
-		v2, changed2 := fastpathTV.DecMapInt16Uint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int16]uint32
+		v2, changed = fastpathTV.DecMapInt16Uint32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int16]uint64:
-		fastpathTV.DecMapInt16Uint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16Uint64V(v, false, d)
 	case *map[int16]uint64:
-		v2, changed2 := fastpathTV.DecMapInt16Uint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int16]uint64
+		v2, changed = fastpathTV.DecMapInt16Uint64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int16]uintptr:
-		fastpathTV.DecMapInt16UintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16UintptrV(v, false, d)
 	case *map[int16]uintptr:
-		v2, changed2 := fastpathTV.DecMapInt16UintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int16]uintptr
+		v2, changed = fastpathTV.DecMapInt16UintptrV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int16]int:
-		fastpathTV.DecMapInt16IntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16IntV(v, false, d)
 	case *map[int16]int:
-		v2, changed2 := fastpathTV.DecMapInt16IntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int16]int
+		v2, changed = fastpathTV.DecMapInt16IntV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int16]int8:
-		fastpathTV.DecMapInt16Int8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16Int8V(v, false, d)
 	case *map[int16]int8:
-		v2, changed2 := fastpathTV.DecMapInt16Int8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int16]int8
+		v2, changed = fastpathTV.DecMapInt16Int8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int16]int16:
-		fastpathTV.DecMapInt16Int16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16Int16V(v, false, d)
 	case *map[int16]int16:
-		v2, changed2 := fastpathTV.DecMapInt16Int16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int16]int16
+		v2, changed = fastpathTV.DecMapInt16Int16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int16]int32:
-		fastpathTV.DecMapInt16Int32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16Int32V(v, false, d)
 	case *map[int16]int32:
-		v2, changed2 := fastpathTV.DecMapInt16Int32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int16]int32
+		v2, changed = fastpathTV.DecMapInt16Int32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int16]int64:
-		fastpathTV.DecMapInt16Int64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16Int64V(v, false, d)
 	case *map[int16]int64:
-		v2, changed2 := fastpathTV.DecMapInt16Int64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int16]int64
+		v2, changed = fastpathTV.DecMapInt16Int64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int16]float32:
-		fastpathTV.DecMapInt16Float32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16Float32V(v, false, d)
 	case *map[int16]float32:
-		v2, changed2 := fastpathTV.DecMapInt16Float32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int16]float32
+		v2, changed = fastpathTV.DecMapInt16Float32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int16]float64:
-		fastpathTV.DecMapInt16Float64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16Float64V(v, false, d)
 	case *map[int16]float64:
-		v2, changed2 := fastpathTV.DecMapInt16Float64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int16]float64
+		v2, changed = fastpathTV.DecMapInt16Float64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int16]bool:
-		fastpathTV.DecMapInt16BoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt16BoolV(v, false, d)
 	case *map[int16]bool:
-		v2, changed2 := fastpathTV.DecMapInt16BoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int16]bool
+		v2, changed = fastpathTV.DecMapInt16BoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []int32:
-		fastpathTV.DecSliceInt32V(v, fastpathCheckNilFalse, false, d)
-	case *[]int32:
-		v2, changed2 := fastpathTV.DecSliceInt32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
-			*v = v2
-		}
-
 	case map[int32]interface{}:
-		fastpathTV.DecMapInt32IntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32IntfV(v, false, d)
 	case *map[int32]interface{}:
-		v2, changed2 := fastpathTV.DecMapInt32IntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int32]interface{}
+		v2, changed = fastpathTV.DecMapInt32IntfV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int32]string:
-		fastpathTV.DecMapInt32StringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32StringV(v, false, d)
 	case *map[int32]string:
-		v2, changed2 := fastpathTV.DecMapInt32StringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int32]string
+		v2, changed = fastpathTV.DecMapInt32StringV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int32]uint:
-		fastpathTV.DecMapInt32UintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32UintV(v, false, d)
 	case *map[int32]uint:
-		v2, changed2 := fastpathTV.DecMapInt32UintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int32]uint
+		v2, changed = fastpathTV.DecMapInt32UintV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int32]uint8:
-		fastpathTV.DecMapInt32Uint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32Uint8V(v, false, d)
 	case *map[int32]uint8:
-		v2, changed2 := fastpathTV.DecMapInt32Uint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int32]uint8
+		v2, changed = fastpathTV.DecMapInt32Uint8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int32]uint16:
-		fastpathTV.DecMapInt32Uint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32Uint16V(v, false, d)
 	case *map[int32]uint16:
-		v2, changed2 := fastpathTV.DecMapInt32Uint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int32]uint16
+		v2, changed = fastpathTV.DecMapInt32Uint16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int32]uint32:
-		fastpathTV.DecMapInt32Uint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32Uint32V(v, false, d)
 	case *map[int32]uint32:
-		v2, changed2 := fastpathTV.DecMapInt32Uint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int32]uint32
+		v2, changed = fastpathTV.DecMapInt32Uint32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int32]uint64:
-		fastpathTV.DecMapInt32Uint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32Uint64V(v, false, d)
 	case *map[int32]uint64:
-		v2, changed2 := fastpathTV.DecMapInt32Uint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int32]uint64
+		v2, changed = fastpathTV.DecMapInt32Uint64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int32]uintptr:
-		fastpathTV.DecMapInt32UintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32UintptrV(v, false, d)
 	case *map[int32]uintptr:
-		v2, changed2 := fastpathTV.DecMapInt32UintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int32]uintptr
+		v2, changed = fastpathTV.DecMapInt32UintptrV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int32]int:
-		fastpathTV.DecMapInt32IntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32IntV(v, false, d)
 	case *map[int32]int:
-		v2, changed2 := fastpathTV.DecMapInt32IntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int32]int
+		v2, changed = fastpathTV.DecMapInt32IntV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int32]int8:
-		fastpathTV.DecMapInt32Int8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32Int8V(v, false, d)
 	case *map[int32]int8:
-		v2, changed2 := fastpathTV.DecMapInt32Int8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int32]int8
+		v2, changed = fastpathTV.DecMapInt32Int8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int32]int16:
-		fastpathTV.DecMapInt32Int16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32Int16V(v, false, d)
 	case *map[int32]int16:
-		v2, changed2 := fastpathTV.DecMapInt32Int16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int32]int16
+		v2, changed = fastpathTV.DecMapInt32Int16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int32]int32:
-		fastpathTV.DecMapInt32Int32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32Int32V(v, false, d)
 	case *map[int32]int32:
-		v2, changed2 := fastpathTV.DecMapInt32Int32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int32]int32
+		v2, changed = fastpathTV.DecMapInt32Int32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int32]int64:
-		fastpathTV.DecMapInt32Int64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32Int64V(v, false, d)
 	case *map[int32]int64:
-		v2, changed2 := fastpathTV.DecMapInt32Int64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int32]int64
+		v2, changed = fastpathTV.DecMapInt32Int64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int32]float32:
-		fastpathTV.DecMapInt32Float32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32Float32V(v, false, d)
 	case *map[int32]float32:
-		v2, changed2 := fastpathTV.DecMapInt32Float32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int32]float32
+		v2, changed = fastpathTV.DecMapInt32Float32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int32]float64:
-		fastpathTV.DecMapInt32Float64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32Float64V(v, false, d)
 	case *map[int32]float64:
-		v2, changed2 := fastpathTV.DecMapInt32Float64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int32]float64
+		v2, changed = fastpathTV.DecMapInt32Float64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int32]bool:
-		fastpathTV.DecMapInt32BoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt32BoolV(v, false, d)
 	case *map[int32]bool:
-		v2, changed2 := fastpathTV.DecMapInt32BoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int32]bool
+		v2, changed = fastpathTV.DecMapInt32BoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []int64:
-		fastpathTV.DecSliceInt64V(v, fastpathCheckNilFalse, false, d)
-	case *[]int64:
-		v2, changed2 := fastpathTV.DecSliceInt64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
-			*v = v2
-		}
-
 	case map[int64]interface{}:
-		fastpathTV.DecMapInt64IntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64IntfV(v, false, d)
 	case *map[int64]interface{}:
-		v2, changed2 := fastpathTV.DecMapInt64IntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int64]interface{}
+		v2, changed = fastpathTV.DecMapInt64IntfV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int64]string:
-		fastpathTV.DecMapInt64StringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64StringV(v, false, d)
 	case *map[int64]string:
-		v2, changed2 := fastpathTV.DecMapInt64StringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int64]string
+		v2, changed = fastpathTV.DecMapInt64StringV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int64]uint:
-		fastpathTV.DecMapInt64UintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64UintV(v, false, d)
 	case *map[int64]uint:
-		v2, changed2 := fastpathTV.DecMapInt64UintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int64]uint
+		v2, changed = fastpathTV.DecMapInt64UintV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int64]uint8:
-		fastpathTV.DecMapInt64Uint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64Uint8V(v, false, d)
 	case *map[int64]uint8:
-		v2, changed2 := fastpathTV.DecMapInt64Uint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int64]uint8
+		v2, changed = fastpathTV.DecMapInt64Uint8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int64]uint16:
-		fastpathTV.DecMapInt64Uint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64Uint16V(v, false, d)
 	case *map[int64]uint16:
-		v2, changed2 := fastpathTV.DecMapInt64Uint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int64]uint16
+		v2, changed = fastpathTV.DecMapInt64Uint16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int64]uint32:
-		fastpathTV.DecMapInt64Uint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64Uint32V(v, false, d)
 	case *map[int64]uint32:
-		v2, changed2 := fastpathTV.DecMapInt64Uint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int64]uint32
+		v2, changed = fastpathTV.DecMapInt64Uint32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int64]uint64:
-		fastpathTV.DecMapInt64Uint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64Uint64V(v, false, d)
 	case *map[int64]uint64:
-		v2, changed2 := fastpathTV.DecMapInt64Uint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int64]uint64
+		v2, changed = fastpathTV.DecMapInt64Uint64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int64]uintptr:
-		fastpathTV.DecMapInt64UintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64UintptrV(v, false, d)
 	case *map[int64]uintptr:
-		v2, changed2 := fastpathTV.DecMapInt64UintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int64]uintptr
+		v2, changed = fastpathTV.DecMapInt64UintptrV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int64]int:
-		fastpathTV.DecMapInt64IntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64IntV(v, false, d)
 	case *map[int64]int:
-		v2, changed2 := fastpathTV.DecMapInt64IntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int64]int
+		v2, changed = fastpathTV.DecMapInt64IntV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int64]int8:
-		fastpathTV.DecMapInt64Int8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64Int8V(v, false, d)
 	case *map[int64]int8:
-		v2, changed2 := fastpathTV.DecMapInt64Int8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int64]int8
+		v2, changed = fastpathTV.DecMapInt64Int8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int64]int16:
-		fastpathTV.DecMapInt64Int16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64Int16V(v, false, d)
 	case *map[int64]int16:
-		v2, changed2 := fastpathTV.DecMapInt64Int16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int64]int16
+		v2, changed = fastpathTV.DecMapInt64Int16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int64]int32:
-		fastpathTV.DecMapInt64Int32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64Int32V(v, false, d)
 	case *map[int64]int32:
-		v2, changed2 := fastpathTV.DecMapInt64Int32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int64]int32
+		v2, changed = fastpathTV.DecMapInt64Int32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int64]int64:
-		fastpathTV.DecMapInt64Int64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64Int64V(v, false, d)
 	case *map[int64]int64:
-		v2, changed2 := fastpathTV.DecMapInt64Int64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int64]int64
+		v2, changed = fastpathTV.DecMapInt64Int64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int64]float32:
-		fastpathTV.DecMapInt64Float32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64Float32V(v, false, d)
 	case *map[int64]float32:
-		v2, changed2 := fastpathTV.DecMapInt64Float32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int64]float32
+		v2, changed = fastpathTV.DecMapInt64Float32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int64]float64:
-		fastpathTV.DecMapInt64Float64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64Float64V(v, false, d)
 	case *map[int64]float64:
-		v2, changed2 := fastpathTV.DecMapInt64Float64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int64]float64
+		v2, changed = fastpathTV.DecMapInt64Float64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[int64]bool:
-		fastpathTV.DecMapInt64BoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapInt64BoolV(v, false, d)
 	case *map[int64]bool:
-		v2, changed2 := fastpathTV.DecMapInt64BoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[int64]bool
+		v2, changed = fastpathTV.DecMapInt64BoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []bool:
-		fastpathTV.DecSliceBoolV(v, fastpathCheckNilFalse, false, d)
-	case *[]bool:
-		v2, changed2 := fastpathTV.DecSliceBoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
-			*v = v2
-		}
-
 	case map[bool]interface{}:
-		fastpathTV.DecMapBoolIntfV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolIntfV(v, false, d)
 	case *map[bool]interface{}:
-		v2, changed2 := fastpathTV.DecMapBoolIntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[bool]interface{}
+		v2, changed = fastpathTV.DecMapBoolIntfV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[bool]string:
-		fastpathTV.DecMapBoolStringV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolStringV(v, false, d)
 	case *map[bool]string:
-		v2, changed2 := fastpathTV.DecMapBoolStringV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[bool]string
+		v2, changed = fastpathTV.DecMapBoolStringV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[bool]uint:
-		fastpathTV.DecMapBoolUintV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolUintV(v, false, d)
 	case *map[bool]uint:
-		v2, changed2 := fastpathTV.DecMapBoolUintV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[bool]uint
+		v2, changed = fastpathTV.DecMapBoolUintV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[bool]uint8:
-		fastpathTV.DecMapBoolUint8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolUint8V(v, false, d)
 	case *map[bool]uint8:
-		v2, changed2 := fastpathTV.DecMapBoolUint8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[bool]uint8
+		v2, changed = fastpathTV.DecMapBoolUint8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[bool]uint16:
-		fastpathTV.DecMapBoolUint16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolUint16V(v, false, d)
 	case *map[bool]uint16:
-		v2, changed2 := fastpathTV.DecMapBoolUint16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[bool]uint16
+		v2, changed = fastpathTV.DecMapBoolUint16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[bool]uint32:
-		fastpathTV.DecMapBoolUint32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolUint32V(v, false, d)
 	case *map[bool]uint32:
-		v2, changed2 := fastpathTV.DecMapBoolUint32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[bool]uint32
+		v2, changed = fastpathTV.DecMapBoolUint32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[bool]uint64:
-		fastpathTV.DecMapBoolUint64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolUint64V(v, false, d)
 	case *map[bool]uint64:
-		v2, changed2 := fastpathTV.DecMapBoolUint64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[bool]uint64
+		v2, changed = fastpathTV.DecMapBoolUint64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[bool]uintptr:
-		fastpathTV.DecMapBoolUintptrV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolUintptrV(v, false, d)
 	case *map[bool]uintptr:
-		v2, changed2 := fastpathTV.DecMapBoolUintptrV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[bool]uintptr
+		v2, changed = fastpathTV.DecMapBoolUintptrV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[bool]int:
-		fastpathTV.DecMapBoolIntV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolIntV(v, false, d)
 	case *map[bool]int:
-		v2, changed2 := fastpathTV.DecMapBoolIntV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[bool]int
+		v2, changed = fastpathTV.DecMapBoolIntV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[bool]int8:
-		fastpathTV.DecMapBoolInt8V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolInt8V(v, false, d)
 	case *map[bool]int8:
-		v2, changed2 := fastpathTV.DecMapBoolInt8V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[bool]int8
+		v2, changed = fastpathTV.DecMapBoolInt8V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[bool]int16:
-		fastpathTV.DecMapBoolInt16V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolInt16V(v, false, d)
 	case *map[bool]int16:
-		v2, changed2 := fastpathTV.DecMapBoolInt16V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[bool]int16
+		v2, changed = fastpathTV.DecMapBoolInt16V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[bool]int32:
-		fastpathTV.DecMapBoolInt32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolInt32V(v, false, d)
 	case *map[bool]int32:
-		v2, changed2 := fastpathTV.DecMapBoolInt32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[bool]int32
+		v2, changed = fastpathTV.DecMapBoolInt32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[bool]int64:
-		fastpathTV.DecMapBoolInt64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolInt64V(v, false, d)
 	case *map[bool]int64:
-		v2, changed2 := fastpathTV.DecMapBoolInt64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[bool]int64
+		v2, changed = fastpathTV.DecMapBoolInt64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[bool]float32:
-		fastpathTV.DecMapBoolFloat32V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolFloat32V(v, false, d)
 	case *map[bool]float32:
-		v2, changed2 := fastpathTV.DecMapBoolFloat32V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[bool]float32
+		v2, changed = fastpathTV.DecMapBoolFloat32V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[bool]float64:
-		fastpathTV.DecMapBoolFloat64V(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolFloat64V(v, false, d)
 	case *map[bool]float64:
-		v2, changed2 := fastpathTV.DecMapBoolFloat64V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[bool]float64
+		v2, changed = fastpathTV.DecMapBoolFloat64V(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	case map[bool]bool:
-		fastpathTV.DecMapBoolBoolV(v, fastpathCheckNilFalse, false, d)
+		fastpathTV.DecMapBoolBoolV(v, false, d)
 	case *map[bool]bool:
-		v2, changed2 := fastpathTV.DecMapBoolBoolV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 map[bool]bool
+		v2, changed = fastpathTV.DecMapBoolBoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
+	default:
+		_ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
+		return false
+	}
+	return true
+}
 
+func fastpathDecodeSetZeroTypeSwitch(iv interface{}) bool {
+	switch v := iv.(type) {
+
+	case *[]interface{}:
+		*v = nil
+	case *[]string:
+		*v = nil
+	case *[]float32:
+		*v = nil
+	case *[]float64:
+		*v = nil
+	case *[]uint:
+		*v = nil
+	case *[]uint8:
+		*v = nil
+	case *[]uint16:
+		*v = nil
+	case *[]uint32:
+		*v = nil
+	case *[]uint64:
+		*v = nil
+	case *[]uintptr:
+		*v = nil
+	case *[]int:
+		*v = nil
+	case *[]int8:
+		*v = nil
+	case *[]int16:
+		*v = nil
+	case *[]int32:
+		*v = nil
+	case *[]int64:
+		*v = nil
+	case *[]bool:
+		*v = nil
+
+	case *map[interface{}]interface{}:
+		*v = nil
+	case *map[interface{}]string:
+		*v = nil
+	case *map[interface{}]uint:
+		*v = nil
+	case *map[interface{}]uint8:
+		*v = nil
+	case *map[interface{}]uint16:
+		*v = nil
+	case *map[interface{}]uint32:
+		*v = nil
+	case *map[interface{}]uint64:
+		*v = nil
+	case *map[interface{}]uintptr:
+		*v = nil
+	case *map[interface{}]int:
+		*v = nil
+	case *map[interface{}]int8:
+		*v = nil
+	case *map[interface{}]int16:
+		*v = nil
+	case *map[interface{}]int32:
+		*v = nil
+	case *map[interface{}]int64:
+		*v = nil
+	case *map[interface{}]float32:
+		*v = nil
+	case *map[interface{}]float64:
+		*v = nil
+	case *map[interface{}]bool:
+		*v = nil
+	case *map[string]interface{}:
+		*v = nil
+	case *map[string]string:
+		*v = nil
+	case *map[string]uint:
+		*v = nil
+	case *map[string]uint8:
+		*v = nil
+	case *map[string]uint16:
+		*v = nil
+	case *map[string]uint32:
+		*v = nil
+	case *map[string]uint64:
+		*v = nil
+	case *map[string]uintptr:
+		*v = nil
+	case *map[string]int:
+		*v = nil
+	case *map[string]int8:
+		*v = nil
+	case *map[string]int16:
+		*v = nil
+	case *map[string]int32:
+		*v = nil
+	case *map[string]int64:
+		*v = nil
+	case *map[string]float32:
+		*v = nil
+	case *map[string]float64:
+		*v = nil
+	case *map[string]bool:
+		*v = nil
+	case *map[float32]interface{}:
+		*v = nil
+	case *map[float32]string:
+		*v = nil
+	case *map[float32]uint:
+		*v = nil
+	case *map[float32]uint8:
+		*v = nil
+	case *map[float32]uint16:
+		*v = nil
+	case *map[float32]uint32:
+		*v = nil
+	case *map[float32]uint64:
+		*v = nil
+	case *map[float32]uintptr:
+		*v = nil
+	case *map[float32]int:
+		*v = nil
+	case *map[float32]int8:
+		*v = nil
+	case *map[float32]int16:
+		*v = nil
+	case *map[float32]int32:
+		*v = nil
+	case *map[float32]int64:
+		*v = nil
+	case *map[float32]float32:
+		*v = nil
+	case *map[float32]float64:
+		*v = nil
+	case *map[float32]bool:
+		*v = nil
+	case *map[float64]interface{}:
+		*v = nil
+	case *map[float64]string:
+		*v = nil
+	case *map[float64]uint:
+		*v = nil
+	case *map[float64]uint8:
+		*v = nil
+	case *map[float64]uint16:
+		*v = nil
+	case *map[float64]uint32:
+		*v = nil
+	case *map[float64]uint64:
+		*v = nil
+	case *map[float64]uintptr:
+		*v = nil
+	case *map[float64]int:
+		*v = nil
+	case *map[float64]int8:
+		*v = nil
+	case *map[float64]int16:
+		*v = nil
+	case *map[float64]int32:
+		*v = nil
+	case *map[float64]int64:
+		*v = nil
+	case *map[float64]float32:
+		*v = nil
+	case *map[float64]float64:
+		*v = nil
+	case *map[float64]bool:
+		*v = nil
+	case *map[uint]interface{}:
+		*v = nil
+	case *map[uint]string:
+		*v = nil
+	case *map[uint]uint:
+		*v = nil
+	case *map[uint]uint8:
+		*v = nil
+	case *map[uint]uint16:
+		*v = nil
+	case *map[uint]uint32:
+		*v = nil
+	case *map[uint]uint64:
+		*v = nil
+	case *map[uint]uintptr:
+		*v = nil
+	case *map[uint]int:
+		*v = nil
+	case *map[uint]int8:
+		*v = nil
+	case *map[uint]int16:
+		*v = nil
+	case *map[uint]int32:
+		*v = nil
+	case *map[uint]int64:
+		*v = nil
+	case *map[uint]float32:
+		*v = nil
+	case *map[uint]float64:
+		*v = nil
+	case *map[uint]bool:
+		*v = nil
+	case *map[uint8]interface{}:
+		*v = nil
+	case *map[uint8]string:
+		*v = nil
+	case *map[uint8]uint:
+		*v = nil
+	case *map[uint8]uint8:
+		*v = nil
+	case *map[uint8]uint16:
+		*v = nil
+	case *map[uint8]uint32:
+		*v = nil
+	case *map[uint8]uint64:
+		*v = nil
+	case *map[uint8]uintptr:
+		*v = nil
+	case *map[uint8]int:
+		*v = nil
+	case *map[uint8]int8:
+		*v = nil
+	case *map[uint8]int16:
+		*v = nil
+	case *map[uint8]int32:
+		*v = nil
+	case *map[uint8]int64:
+		*v = nil
+	case *map[uint8]float32:
+		*v = nil
+	case *map[uint8]float64:
+		*v = nil
+	case *map[uint8]bool:
+		*v = nil
+	case *map[uint16]interface{}:
+		*v = nil
+	case *map[uint16]string:
+		*v = nil
+	case *map[uint16]uint:
+		*v = nil
+	case *map[uint16]uint8:
+		*v = nil
+	case *map[uint16]uint16:
+		*v = nil
+	case *map[uint16]uint32:
+		*v = nil
+	case *map[uint16]uint64:
+		*v = nil
+	case *map[uint16]uintptr:
+		*v = nil
+	case *map[uint16]int:
+		*v = nil
+	case *map[uint16]int8:
+		*v = nil
+	case *map[uint16]int16:
+		*v = nil
+	case *map[uint16]int32:
+		*v = nil
+	case *map[uint16]int64:
+		*v = nil
+	case *map[uint16]float32:
+		*v = nil
+	case *map[uint16]float64:
+		*v = nil
+	case *map[uint16]bool:
+		*v = nil
+	case *map[uint32]interface{}:
+		*v = nil
+	case *map[uint32]string:
+		*v = nil
+	case *map[uint32]uint:
+		*v = nil
+	case *map[uint32]uint8:
+		*v = nil
+	case *map[uint32]uint16:
+		*v = nil
+	case *map[uint32]uint32:
+		*v = nil
+	case *map[uint32]uint64:
+		*v = nil
+	case *map[uint32]uintptr:
+		*v = nil
+	case *map[uint32]int:
+		*v = nil
+	case *map[uint32]int8:
+		*v = nil
+	case *map[uint32]int16:
+		*v = nil
+	case *map[uint32]int32:
+		*v = nil
+	case *map[uint32]int64:
+		*v = nil
+	case *map[uint32]float32:
+		*v = nil
+	case *map[uint32]float64:
+		*v = nil
+	case *map[uint32]bool:
+		*v = nil
+	case *map[uint64]interface{}:
+		*v = nil
+	case *map[uint64]string:
+		*v = nil
+	case *map[uint64]uint:
+		*v = nil
+	case *map[uint64]uint8:
+		*v = nil
+	case *map[uint64]uint16:
+		*v = nil
+	case *map[uint64]uint32:
+		*v = nil
+	case *map[uint64]uint64:
+		*v = nil
+	case *map[uint64]uintptr:
+		*v = nil
+	case *map[uint64]int:
+		*v = nil
+	case *map[uint64]int8:
+		*v = nil
+	case *map[uint64]int16:
+		*v = nil
+	case *map[uint64]int32:
+		*v = nil
+	case *map[uint64]int64:
+		*v = nil
+	case *map[uint64]float32:
+		*v = nil
+	case *map[uint64]float64:
+		*v = nil
+	case *map[uint64]bool:
+		*v = nil
+	case *map[uintptr]interface{}:
+		*v = nil
+	case *map[uintptr]string:
+		*v = nil
+	case *map[uintptr]uint:
+		*v = nil
+	case *map[uintptr]uint8:
+		*v = nil
+	case *map[uintptr]uint16:
+		*v = nil
+	case *map[uintptr]uint32:
+		*v = nil
+	case *map[uintptr]uint64:
+		*v = nil
+	case *map[uintptr]uintptr:
+		*v = nil
+	case *map[uintptr]int:
+		*v = nil
+	case *map[uintptr]int8:
+		*v = nil
+	case *map[uintptr]int16:
+		*v = nil
+	case *map[uintptr]int32:
+		*v = nil
+	case *map[uintptr]int64:
+		*v = nil
+	case *map[uintptr]float32:
+		*v = nil
+	case *map[uintptr]float64:
+		*v = nil
+	case *map[uintptr]bool:
+		*v = nil
+	case *map[int]interface{}:
+		*v = nil
+	case *map[int]string:
+		*v = nil
+	case *map[int]uint:
+		*v = nil
+	case *map[int]uint8:
+		*v = nil
+	case *map[int]uint16:
+		*v = nil
+	case *map[int]uint32:
+		*v = nil
+	case *map[int]uint64:
+		*v = nil
+	case *map[int]uintptr:
+		*v = nil
+	case *map[int]int:
+		*v = nil
+	case *map[int]int8:
+		*v = nil
+	case *map[int]int16:
+		*v = nil
+	case *map[int]int32:
+		*v = nil
+	case *map[int]int64:
+		*v = nil
+	case *map[int]float32:
+		*v = nil
+	case *map[int]float64:
+		*v = nil
+	case *map[int]bool:
+		*v = nil
+	case *map[int8]interface{}:
+		*v = nil
+	case *map[int8]string:
+		*v = nil
+	case *map[int8]uint:
+		*v = nil
+	case *map[int8]uint8:
+		*v = nil
+	case *map[int8]uint16:
+		*v = nil
+	case *map[int8]uint32:
+		*v = nil
+	case *map[int8]uint64:
+		*v = nil
+	case *map[int8]uintptr:
+		*v = nil
+	case *map[int8]int:
+		*v = nil
+	case *map[int8]int8:
+		*v = nil
+	case *map[int8]int16:
+		*v = nil
+	case *map[int8]int32:
+		*v = nil
+	case *map[int8]int64:
+		*v = nil
+	case *map[int8]float32:
+		*v = nil
+	case *map[int8]float64:
+		*v = nil
+	case *map[int8]bool:
+		*v = nil
+	case *map[int16]interface{}:
+		*v = nil
+	case *map[int16]string:
+		*v = nil
+	case *map[int16]uint:
+		*v = nil
+	case *map[int16]uint8:
+		*v = nil
+	case *map[int16]uint16:
+		*v = nil
+	case *map[int16]uint32:
+		*v = nil
+	case *map[int16]uint64:
+		*v = nil
+	case *map[int16]uintptr:
+		*v = nil
+	case *map[int16]int:
+		*v = nil
+	case *map[int16]int8:
+		*v = nil
+	case *map[int16]int16:
+		*v = nil
+	case *map[int16]int32:
+		*v = nil
+	case *map[int16]int64:
+		*v = nil
+	case *map[int16]float32:
+		*v = nil
+	case *map[int16]float64:
+		*v = nil
+	case *map[int16]bool:
+		*v = nil
+	case *map[int32]interface{}:
+		*v = nil
+	case *map[int32]string:
+		*v = nil
+	case *map[int32]uint:
+		*v = nil
+	case *map[int32]uint8:
+		*v = nil
+	case *map[int32]uint16:
+		*v = nil
+	case *map[int32]uint32:
+		*v = nil
+	case *map[int32]uint64:
+		*v = nil
+	case *map[int32]uintptr:
+		*v = nil
+	case *map[int32]int:
+		*v = nil
+	case *map[int32]int8:
+		*v = nil
+	case *map[int32]int16:
+		*v = nil
+	case *map[int32]int32:
+		*v = nil
+	case *map[int32]int64:
+		*v = nil
+	case *map[int32]float32:
+		*v = nil
+	case *map[int32]float64:
+		*v = nil
+	case *map[int32]bool:
+		*v = nil
+	case *map[int64]interface{}:
+		*v = nil
+	case *map[int64]string:
+		*v = nil
+	case *map[int64]uint:
+		*v = nil
+	case *map[int64]uint8:
+		*v = nil
+	case *map[int64]uint16:
+		*v = nil
+	case *map[int64]uint32:
+		*v = nil
+	case *map[int64]uint64:
+		*v = nil
+	case *map[int64]uintptr:
+		*v = nil
+	case *map[int64]int:
+		*v = nil
+	case *map[int64]int8:
+		*v = nil
+	case *map[int64]int16:
+		*v = nil
+	case *map[int64]int32:
+		*v = nil
+	case *map[int64]int64:
+		*v = nil
+	case *map[int64]float32:
+		*v = nil
+	case *map[int64]float64:
+		*v = nil
+	case *map[int64]bool:
+		*v = nil
+	case *map[bool]interface{}:
+		*v = nil
+	case *map[bool]string:
+		*v = nil
+	case *map[bool]uint:
+		*v = nil
+	case *map[bool]uint8:
+		*v = nil
+	case *map[bool]uint16:
+		*v = nil
+	case *map[bool]uint32:
+		*v = nil
+	case *map[bool]uint64:
+		*v = nil
+	case *map[bool]uintptr:
+		*v = nil
+	case *map[bool]int:
+		*v = nil
+	case *map[bool]int8:
+		*v = nil
+	case *map[bool]int16:
+		*v = nil
+	case *map[bool]int32:
+		*v = nil
+	case *map[bool]int64:
+		*v = nil
+	case *map[bool]float32:
+		*v = nil
+	case *map[bool]float64:
+		*v = nil
+	case *map[bool]bool:
+		*v = nil
 	default:
 		_ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
 		return false
@@ -18123,35 +16201,29 @@ func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool {
 
 // -- -- fast path functions
 
-func (f *decFnInfo) fastpathDecSliceIntfR(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*[]interface{})
-		v, changed := fastpathTV.DecSliceIntfV(*vp, fastpathCheckNilFalse, !array, f.d)
+func (d *Decoder) fastpathDecSliceIntfR(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]interface{})
+		v, changed := fastpathTV.DecSliceIntfV(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
 		v := rv2i(rv).([]interface{})
-		fastpathTV.DecSliceIntfV(v, fastpathCheckNilFalse, false, f.d)
+		v2, changed := fastpathTV.DecSliceIntfV(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceIntfX(vp *[]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceIntfV(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceIntfX(vp *[]interface{}, d *Decoder) {
+	v, changed := f.DecSliceIntfV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceIntfV(v []interface{}, checkNil bool, canChange bool, d *Decoder) (_ []interface{}, changed bool) {
+func (_ fastpathT) DecSliceIntfV(v []interface{}, canChange bool, d *Decoder) (_ []interface{}, changed bool) {
 	dd := d.d
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -18165,7 +16237,6 @@ func (_ fastpathT) DecSliceIntfV(v []interface{}, checkNil bool, canChange bool,
 		slh.End()
 		return v, changed
 	}
-
 	hasLen := containerLenS > 0
 	var xlen int
 	if hasLen && canChange {
@@ -18184,7 +16255,7 @@ func (_ fastpathT) DecSliceIntfV(v []interface{}, checkNil bool, canChange bool,
 	}
 	j := 0
 	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
-		if j == 0 && len(v) == 0 {
+		if j == 0 && len(v) == 0 && canChange {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
 			} else {
@@ -18207,6 +16278,8 @@ func (_ fastpathT) DecSliceIntfV(v []interface{}, checkNil bool, canChange bool,
 		slh.ElemContainerState(j)
 		if decodeIntoBlank {
 			d.swallow()
+		} else if dd.TryDecodeAsNil() {
+			v[j] = nil
 		} else {
 			d.decode(&v[j])
 		}
@@ -18224,35 +16297,29 @@ func (_ fastpathT) DecSliceIntfV(v []interface{}, checkNil bool, canChange bool,
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceStringR(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*[]string)
-		v, changed := fastpathTV.DecSliceStringV(*vp, fastpathCheckNilFalse, !array, f.d)
+func (d *Decoder) fastpathDecSliceStringR(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]string)
+		v, changed := fastpathTV.DecSliceStringV(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
 		v := rv2i(rv).([]string)
-		fastpathTV.DecSliceStringV(v, fastpathCheckNilFalse, false, f.d)
+		v2, changed := fastpathTV.DecSliceStringV(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceStringX(vp *[]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceStringV(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceStringX(vp *[]string, d *Decoder) {
+	v, changed := f.DecSliceStringV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceStringV(v []string, checkNil bool, canChange bool, d *Decoder) (_ []string, changed bool) {
+func (_ fastpathT) DecSliceStringV(v []string, canChange bool, d *Decoder) (_ []string, changed bool) {
 	dd := d.d
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -18266,7 +16333,6 @@ func (_ fastpathT) DecSliceStringV(v []string, checkNil bool, canChange bool, d
 		slh.End()
 		return v, changed
 	}
-
 	hasLen := containerLenS > 0
 	var xlen int
 	if hasLen && canChange {
@@ -18285,7 +16351,7 @@ func (_ fastpathT) DecSliceStringV(v []string, checkNil bool, canChange bool, d
 	}
 	j := 0
 	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
-		if j == 0 && len(v) == 0 {
+		if j == 0 && len(v) == 0 && canChange {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
 			} else {
@@ -18308,6 +16374,8 @@ func (_ fastpathT) DecSliceStringV(v []string, checkNil bool, canChange bool, d
 		slh.ElemContainerState(j)
 		if decodeIntoBlank {
 			d.swallow()
+		} else if dd.TryDecodeAsNil() {
+			v[j] = ""
 		} else {
 			v[j] = dd.DecodeString()
 		}
@@ -18325,35 +16393,29 @@ func (_ fastpathT) DecSliceStringV(v []string, checkNil bool, canChange bool, d
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceFloat32R(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*[]float32)
-		v, changed := fastpathTV.DecSliceFloat32V(*vp, fastpathCheckNilFalse, !array, f.d)
+func (d *Decoder) fastpathDecSliceFloat32R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]float32)
+		v, changed := fastpathTV.DecSliceFloat32V(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
 		v := rv2i(rv).([]float32)
-		fastpathTV.DecSliceFloat32V(v, fastpathCheckNilFalse, false, f.d)
+		v2, changed := fastpathTV.DecSliceFloat32V(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceFloat32X(vp *[]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceFloat32V(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceFloat32X(vp *[]float32, d *Decoder) {
+	v, changed := f.DecSliceFloat32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceFloat32V(v []float32, checkNil bool, canChange bool, d *Decoder) (_ []float32, changed bool) {
+func (_ fastpathT) DecSliceFloat32V(v []float32, canChange bool, d *Decoder) (_ []float32, changed bool) {
 	dd := d.d
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -18367,7 +16429,6 @@ func (_ fastpathT) DecSliceFloat32V(v []float32, checkNil bool, canChange bool,
 		slh.End()
 		return v, changed
 	}
-
 	hasLen := containerLenS > 0
 	var xlen int
 	if hasLen && canChange {
@@ -18386,7 +16447,7 @@ func (_ fastpathT) DecSliceFloat32V(v []float32, checkNil bool, canChange bool,
 	}
 	j := 0
 	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
-		if j == 0 && len(v) == 0 {
+		if j == 0 && len(v) == 0 && canChange {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
 			} else {
@@ -18409,8 +16470,10 @@ func (_ fastpathT) DecSliceFloat32V(v []float32, checkNil bool, canChange bool,
 		slh.ElemContainerState(j)
 		if decodeIntoBlank {
 			d.swallow()
+		} else if dd.TryDecodeAsNil() {
+			v[j] = 0
 		} else {
-			v[j] = float32(dd.DecodeFloat(true))
+			v[j] = float32(chkFloat32(dd.DecodeFloat64()))
 		}
 	}
 	if canChange {
@@ -18426,35 +16489,29 @@ func (_ fastpathT) DecSliceFloat32V(v []float32, checkNil bool, canChange bool,
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceFloat64R(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*[]float64)
-		v, changed := fastpathTV.DecSliceFloat64V(*vp, fastpathCheckNilFalse, !array, f.d)
+func (d *Decoder) fastpathDecSliceFloat64R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]float64)
+		v, changed := fastpathTV.DecSliceFloat64V(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
 		v := rv2i(rv).([]float64)
-		fastpathTV.DecSliceFloat64V(v, fastpathCheckNilFalse, false, f.d)
+		v2, changed := fastpathTV.DecSliceFloat64V(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceFloat64X(vp *[]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceFloat64V(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceFloat64X(vp *[]float64, d *Decoder) {
+	v, changed := f.DecSliceFloat64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceFloat64V(v []float64, checkNil bool, canChange bool, d *Decoder) (_ []float64, changed bool) {
+func (_ fastpathT) DecSliceFloat64V(v []float64, canChange bool, d *Decoder) (_ []float64, changed bool) {
 	dd := d.d
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -18468,7 +16525,6 @@ func (_ fastpathT) DecSliceFloat64V(v []float64, checkNil bool, canChange bool,
 		slh.End()
 		return v, changed
 	}
-
 	hasLen := containerLenS > 0
 	var xlen int
 	if hasLen && canChange {
@@ -18487,7 +16543,7 @@ func (_ fastpathT) DecSliceFloat64V(v []float64, checkNil bool, canChange bool,
 	}
 	j := 0
 	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
-		if j == 0 && len(v) == 0 {
+		if j == 0 && len(v) == 0 && canChange {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
 			} else {
@@ -18510,8 +16566,10 @@ func (_ fastpathT) DecSliceFloat64V(v []float64, checkNil bool, canChange bool,
 		slh.ElemContainerState(j)
 		if decodeIntoBlank {
 			d.swallow()
+		} else if dd.TryDecodeAsNil() {
+			v[j] = 0
 		} else {
-			v[j] = dd.DecodeFloat(false)
+			v[j] = dd.DecodeFloat64()
 		}
 	}
 	if canChange {
@@ -18527,35 +16585,29 @@ func (_ fastpathT) DecSliceFloat64V(v []float64, checkNil bool, canChange bool,
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceUintR(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*[]uint)
-		v, changed := fastpathTV.DecSliceUintV(*vp, fastpathCheckNilFalse, !array, f.d)
+func (d *Decoder) fastpathDecSliceUintR(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]uint)
+		v, changed := fastpathTV.DecSliceUintV(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
 		v := rv2i(rv).([]uint)
-		fastpathTV.DecSliceUintV(v, fastpathCheckNilFalse, false, f.d)
+		v2, changed := fastpathTV.DecSliceUintV(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceUintX(vp *[]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceUintV(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceUintX(vp *[]uint, d *Decoder) {
+	v, changed := f.DecSliceUintV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceUintV(v []uint, checkNil bool, canChange bool, d *Decoder) (_ []uint, changed bool) {
+func (_ fastpathT) DecSliceUintV(v []uint, canChange bool, d *Decoder) (_ []uint, changed bool) {
 	dd := d.d
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -18569,7 +16621,6 @@ func (_ fastpathT) DecSliceUintV(v []uint, checkNil bool, canChange bool, d *Dec
 		slh.End()
 		return v, changed
 	}
-
 	hasLen := containerLenS > 0
 	var xlen int
 	if hasLen && canChange {
@@ -18588,7 +16639,7 @@ func (_ fastpathT) DecSliceUintV(v []uint, checkNil bool, canChange bool, d *Dec
 	}
 	j := 0
 	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
-		if j == 0 && len(v) == 0 {
+		if j == 0 && len(v) == 0 && canChange {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
 			} else {
@@ -18611,6 +16662,8 @@ func (_ fastpathT) DecSliceUintV(v []uint, checkNil bool, canChange bool, d *Dec
 		slh.ElemContainerState(j)
 		if decodeIntoBlank {
 			d.swallow()
+		} else if dd.TryDecodeAsNil() {
+			v[j] = 0
 		} else {
 			v[j] = uint(dd.DecodeUint(uintBitsize))
 		}
@@ -18628,35 +16681,125 @@ func (_ fastpathT) DecSliceUintV(v []uint, checkNil bool, canChange bool, d *Dec
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceUint16R(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*[]uint16)
-		v, changed := fastpathTV.DecSliceUint16V(*vp, fastpathCheckNilFalse, !array, f.d)
+func (d *Decoder) fastpathDecSliceUint8R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]uint8)
+		v, changed := fastpathTV.DecSliceUint8V(*vp, !array, d)
+		if changed {
+			*vp = v
+		}
+	} else {
+		v := rv2i(rv).([]uint8)
+		v2, changed := fastpathTV.DecSliceUint8V(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	}
+}
+func (f fastpathT) DecSliceUint8X(vp *[]uint8, d *Decoder) {
+	v, changed := f.DecSliceUint8V(*vp, true, d)
+	if changed {
+		*vp = v
+	}
+}
+func (_ fastpathT) DecSliceUint8V(v []uint8, canChange bool, d *Decoder) (_ []uint8, changed bool) {
+	dd := d.d
+	slh, containerLenS := d.decSliceHelperStart()
+	if containerLenS == 0 {
+		if canChange {
+			if v == nil {
+				v = []uint8{}
+			} else if len(v) != 0 {
+				v = v[:0]
+			}
+			changed = true
+		}
+		slh.End()
+		return v, changed
+	}
+	hasLen := containerLenS > 0
+	var xlen int
+	if hasLen && canChange {
+		if containerLenS > cap(v) {
+			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
+			if xlen <= cap(v) {
+				v = v[:xlen]
+			} else {
+				v = make([]uint8, xlen)
+			}
+			changed = true
+		} else if containerLenS != len(v) {
+			v = v[:containerLenS]
+			changed = true
+		}
+	}
+	j := 0
+	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
+		if j == 0 && len(v) == 0 && canChange {
+			if hasLen {
+				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
+			} else {
+				xlen = 8
+			}
+			v = make([]uint8, xlen)
+			changed = true
+		}
+		// if indefinite, etc, then expand the slice if necessary
+		var decodeIntoBlank bool
+		if j >= len(v) {
+			if canChange {
+				v = append(v, 0)
+				changed = true
+			} else {
+				d.arrayCannotExpand(len(v), j+1)
+				decodeIntoBlank = true
+			}
+		}
+		slh.ElemContainerState(j)
+		if decodeIntoBlank {
+			d.swallow()
+		} else if dd.TryDecodeAsNil() {
+			v[j] = 0
+		} else {
+			v[j] = uint8(dd.DecodeUint(8))
+		}
+	}
+	if canChange {
+		if j < len(v) {
+			v = v[:j]
+			changed = true
+		} else if j == 0 && v == nil {
+			v = make([]uint8, 0)
+			changed = true
+		}
+	}
+	slh.End()
+	return v, changed
+}
+
+func (d *Decoder) fastpathDecSliceUint16R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]uint16)
+		v, changed := fastpathTV.DecSliceUint16V(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
 		v := rv2i(rv).([]uint16)
-		fastpathTV.DecSliceUint16V(v, fastpathCheckNilFalse, false, f.d)
+		v2, changed := fastpathTV.DecSliceUint16V(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceUint16X(vp *[]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceUint16V(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceUint16X(vp *[]uint16, d *Decoder) {
+	v, changed := f.DecSliceUint16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceUint16V(v []uint16, checkNil bool, canChange bool, d *Decoder) (_ []uint16, changed bool) {
+func (_ fastpathT) DecSliceUint16V(v []uint16, canChange bool, d *Decoder) (_ []uint16, changed bool) {
 	dd := d.d
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -18670,7 +16813,6 @@ func (_ fastpathT) DecSliceUint16V(v []uint16, checkNil bool, canChange bool, d
 		slh.End()
 		return v, changed
 	}
-
 	hasLen := containerLenS > 0
 	var xlen int
 	if hasLen && canChange {
@@ -18689,7 +16831,7 @@ func (_ fastpathT) DecSliceUint16V(v []uint16, checkNil bool, canChange bool, d
 	}
 	j := 0
 	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
-		if j == 0 && len(v) == 0 {
+		if j == 0 && len(v) == 0 && canChange {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 2)
 			} else {
@@ -18712,6 +16854,8 @@ func (_ fastpathT) DecSliceUint16V(v []uint16, checkNil bool, canChange bool, d
 		slh.ElemContainerState(j)
 		if decodeIntoBlank {
 			d.swallow()
+		} else if dd.TryDecodeAsNil() {
+			v[j] = 0
 		} else {
 			v[j] = uint16(dd.DecodeUint(16))
 		}
@@ -18729,35 +16873,29 @@ func (_ fastpathT) DecSliceUint16V(v []uint16, checkNil bool, canChange bool, d
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceUint32R(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*[]uint32)
-		v, changed := fastpathTV.DecSliceUint32V(*vp, fastpathCheckNilFalse, !array, f.d)
+func (d *Decoder) fastpathDecSliceUint32R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]uint32)
+		v, changed := fastpathTV.DecSliceUint32V(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
 		v := rv2i(rv).([]uint32)
-		fastpathTV.DecSliceUint32V(v, fastpathCheckNilFalse, false, f.d)
+		v2, changed := fastpathTV.DecSliceUint32V(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceUint32X(vp *[]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceUint32V(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceUint32X(vp *[]uint32, d *Decoder) {
+	v, changed := f.DecSliceUint32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceUint32V(v []uint32, checkNil bool, canChange bool, d *Decoder) (_ []uint32, changed bool) {
+func (_ fastpathT) DecSliceUint32V(v []uint32, canChange bool, d *Decoder) (_ []uint32, changed bool) {
 	dd := d.d
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -18771,7 +16909,6 @@ func (_ fastpathT) DecSliceUint32V(v []uint32, checkNil bool, canChange bool, d
 		slh.End()
 		return v, changed
 	}
-
 	hasLen := containerLenS > 0
 	var xlen int
 	if hasLen && canChange {
@@ -18790,7 +16927,7 @@ func (_ fastpathT) DecSliceUint32V(v []uint32, checkNil bool, canChange bool, d
 	}
 	j := 0
 	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
-		if j == 0 && len(v) == 0 {
+		if j == 0 && len(v) == 0 && canChange {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
 			} else {
@@ -18813,6 +16950,8 @@ func (_ fastpathT) DecSliceUint32V(v []uint32, checkNil bool, canChange bool, d
 		slh.ElemContainerState(j)
 		if decodeIntoBlank {
 			d.swallow()
+		} else if dd.TryDecodeAsNil() {
+			v[j] = 0
 		} else {
 			v[j] = uint32(dd.DecodeUint(32))
 		}
@@ -18830,35 +16969,29 @@ func (_ fastpathT) DecSliceUint32V(v []uint32, checkNil bool, canChange bool, d
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceUint64R(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*[]uint64)
-		v, changed := fastpathTV.DecSliceUint64V(*vp, fastpathCheckNilFalse, !array, f.d)
+func (d *Decoder) fastpathDecSliceUint64R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]uint64)
+		v, changed := fastpathTV.DecSliceUint64V(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
 		v := rv2i(rv).([]uint64)
-		fastpathTV.DecSliceUint64V(v, fastpathCheckNilFalse, false, f.d)
+		v2, changed := fastpathTV.DecSliceUint64V(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceUint64X(vp *[]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceUint64V(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceUint64X(vp *[]uint64, d *Decoder) {
+	v, changed := f.DecSliceUint64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceUint64V(v []uint64, checkNil bool, canChange bool, d *Decoder) (_ []uint64, changed bool) {
+func (_ fastpathT) DecSliceUint64V(v []uint64, canChange bool, d *Decoder) (_ []uint64, changed bool) {
 	dd := d.d
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -18872,7 +17005,6 @@ func (_ fastpathT) DecSliceUint64V(v []uint64, checkNil bool, canChange bool, d
 		slh.End()
 		return v, changed
 	}
-
 	hasLen := containerLenS > 0
 	var xlen int
 	if hasLen && canChange {
@@ -18891,7 +17023,7 @@ func (_ fastpathT) DecSliceUint64V(v []uint64, checkNil bool, canChange bool, d
 	}
 	j := 0
 	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
-		if j == 0 && len(v) == 0 {
+		if j == 0 && len(v) == 0 && canChange {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
 			} else {
@@ -18914,6 +17046,8 @@ func (_ fastpathT) DecSliceUint64V(v []uint64, checkNil bool, canChange bool, d
 		slh.ElemContainerState(j)
 		if decodeIntoBlank {
 			d.swallow()
+		} else if dd.TryDecodeAsNil() {
+			v[j] = 0
 		} else {
 			v[j] = dd.DecodeUint(64)
 		}
@@ -18931,35 +17065,29 @@ func (_ fastpathT) DecSliceUint64V(v []uint64, checkNil bool, canChange bool, d
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceUintptrR(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*[]uintptr)
-		v, changed := fastpathTV.DecSliceUintptrV(*vp, fastpathCheckNilFalse, !array, f.d)
+func (d *Decoder) fastpathDecSliceUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]uintptr)
+		v, changed := fastpathTV.DecSliceUintptrV(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
 		v := rv2i(rv).([]uintptr)
-		fastpathTV.DecSliceUintptrV(v, fastpathCheckNilFalse, false, f.d)
+		v2, changed := fastpathTV.DecSliceUintptrV(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceUintptrX(vp *[]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceUintptrV(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceUintptrX(vp *[]uintptr, d *Decoder) {
+	v, changed := f.DecSliceUintptrV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceUintptrV(v []uintptr, checkNil bool, canChange bool, d *Decoder) (_ []uintptr, changed bool) {
+func (_ fastpathT) DecSliceUintptrV(v []uintptr, canChange bool, d *Decoder) (_ []uintptr, changed bool) {
 	dd := d.d
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -18973,7 +17101,6 @@ func (_ fastpathT) DecSliceUintptrV(v []uintptr, checkNil bool, canChange bool,
 		slh.End()
 		return v, changed
 	}
-
 	hasLen := containerLenS > 0
 	var xlen int
 	if hasLen && canChange {
@@ -18992,7 +17119,7 @@ func (_ fastpathT) DecSliceUintptrV(v []uintptr, checkNil bool, canChange bool,
 	}
 	j := 0
 	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
-		if j == 0 && len(v) == 0 {
+		if j == 0 && len(v) == 0 && canChange {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
 			} else {
@@ -19015,6 +17142,8 @@ func (_ fastpathT) DecSliceUintptrV(v []uintptr, checkNil bool, canChange bool,
 		slh.ElemContainerState(j)
 		if decodeIntoBlank {
 			d.swallow()
+		} else if dd.TryDecodeAsNil() {
+			v[j] = 0
 		} else {
 			v[j] = uintptr(dd.DecodeUint(uintBitsize))
 		}
@@ -19032,35 +17161,29 @@ func (_ fastpathT) DecSliceUintptrV(v []uintptr, checkNil bool, canChange bool,
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceIntR(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*[]int)
-		v, changed := fastpathTV.DecSliceIntV(*vp, fastpathCheckNilFalse, !array, f.d)
+func (d *Decoder) fastpathDecSliceIntR(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]int)
+		v, changed := fastpathTV.DecSliceIntV(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
 		v := rv2i(rv).([]int)
-		fastpathTV.DecSliceIntV(v, fastpathCheckNilFalse, false, f.d)
+		v2, changed := fastpathTV.DecSliceIntV(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceIntX(vp *[]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceIntV(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceIntX(vp *[]int, d *Decoder) {
+	v, changed := f.DecSliceIntV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceIntV(v []int, checkNil bool, canChange bool, d *Decoder) (_ []int, changed bool) {
+func (_ fastpathT) DecSliceIntV(v []int, canChange bool, d *Decoder) (_ []int, changed bool) {
 	dd := d.d
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -19074,7 +17197,6 @@ func (_ fastpathT) DecSliceIntV(v []int, checkNil bool, canChange bool, d *Decod
 		slh.End()
 		return v, changed
 	}
-
 	hasLen := containerLenS > 0
 	var xlen int
 	if hasLen && canChange {
@@ -19093,7 +17215,7 @@ func (_ fastpathT) DecSliceIntV(v []int, checkNil bool, canChange bool, d *Decod
 	}
 	j := 0
 	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
-		if j == 0 && len(v) == 0 {
+		if j == 0 && len(v) == 0 && canChange {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
 			} else {
@@ -19116,6 +17238,8 @@ func (_ fastpathT) DecSliceIntV(v []int, checkNil bool, canChange bool, d *Decod
 		slh.ElemContainerState(j)
 		if decodeIntoBlank {
 			d.swallow()
+		} else if dd.TryDecodeAsNil() {
+			v[j] = 0
 		} else {
 			v[j] = int(dd.DecodeInt(intBitsize))
 		}
@@ -19133,35 +17257,29 @@ func (_ fastpathT) DecSliceIntV(v []int, checkNil bool, canChange bool, d *Decod
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceInt8R(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*[]int8)
-		v, changed := fastpathTV.DecSliceInt8V(*vp, fastpathCheckNilFalse, !array, f.d)
+func (d *Decoder) fastpathDecSliceInt8R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]int8)
+		v, changed := fastpathTV.DecSliceInt8V(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
 		v := rv2i(rv).([]int8)
-		fastpathTV.DecSliceInt8V(v, fastpathCheckNilFalse, false, f.d)
+		v2, changed := fastpathTV.DecSliceInt8V(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceInt8X(vp *[]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceInt8V(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceInt8X(vp *[]int8, d *Decoder) {
+	v, changed := f.DecSliceInt8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceInt8V(v []int8, checkNil bool, canChange bool, d *Decoder) (_ []int8, changed bool) {
+func (_ fastpathT) DecSliceInt8V(v []int8, canChange bool, d *Decoder) (_ []int8, changed bool) {
 	dd := d.d
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -19175,7 +17293,6 @@ func (_ fastpathT) DecSliceInt8V(v []int8, checkNil bool, canChange bool, d *Dec
 		slh.End()
 		return v, changed
 	}
-
 	hasLen := containerLenS > 0
 	var xlen int
 	if hasLen && canChange {
@@ -19194,7 +17311,7 @@ func (_ fastpathT) DecSliceInt8V(v []int8, checkNil bool, canChange bool, d *Dec
 	}
 	j := 0
 	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
-		if j == 0 && len(v) == 0 {
+		if j == 0 && len(v) == 0 && canChange {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
 			} else {
@@ -19217,6 +17334,8 @@ func (_ fastpathT) DecSliceInt8V(v []int8, checkNil bool, canChange bool, d *Dec
 		slh.ElemContainerState(j)
 		if decodeIntoBlank {
 			d.swallow()
+		} else if dd.TryDecodeAsNil() {
+			v[j] = 0
 		} else {
 			v[j] = int8(dd.DecodeInt(8))
 		}
@@ -19234,35 +17353,29 @@ func (_ fastpathT) DecSliceInt8V(v []int8, checkNil bool, canChange bool, d *Dec
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceInt16R(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*[]int16)
-		v, changed := fastpathTV.DecSliceInt16V(*vp, fastpathCheckNilFalse, !array, f.d)
+func (d *Decoder) fastpathDecSliceInt16R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]int16)
+		v, changed := fastpathTV.DecSliceInt16V(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
 		v := rv2i(rv).([]int16)
-		fastpathTV.DecSliceInt16V(v, fastpathCheckNilFalse, false, f.d)
+		v2, changed := fastpathTV.DecSliceInt16V(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceInt16X(vp *[]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceInt16V(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceInt16X(vp *[]int16, d *Decoder) {
+	v, changed := f.DecSliceInt16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceInt16V(v []int16, checkNil bool, canChange bool, d *Decoder) (_ []int16, changed bool) {
+func (_ fastpathT) DecSliceInt16V(v []int16, canChange bool, d *Decoder) (_ []int16, changed bool) {
 	dd := d.d
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -19276,7 +17389,6 @@ func (_ fastpathT) DecSliceInt16V(v []int16, checkNil bool, canChange bool, d *D
 		slh.End()
 		return v, changed
 	}
-
 	hasLen := containerLenS > 0
 	var xlen int
 	if hasLen && canChange {
@@ -19295,7 +17407,7 @@ func (_ fastpathT) DecSliceInt16V(v []int16, checkNil bool, canChange bool, d *D
 	}
 	j := 0
 	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
-		if j == 0 && len(v) == 0 {
+		if j == 0 && len(v) == 0 && canChange {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 2)
 			} else {
@@ -19318,6 +17430,8 @@ func (_ fastpathT) DecSliceInt16V(v []int16, checkNil bool, canChange bool, d *D
 		slh.ElemContainerState(j)
 		if decodeIntoBlank {
 			d.swallow()
+		} else if dd.TryDecodeAsNil() {
+			v[j] = 0
 		} else {
 			v[j] = int16(dd.DecodeInt(16))
 		}
@@ -19335,35 +17449,29 @@ func (_ fastpathT) DecSliceInt16V(v []int16, checkNil bool, canChange bool, d *D
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceInt32R(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*[]int32)
-		v, changed := fastpathTV.DecSliceInt32V(*vp, fastpathCheckNilFalse, !array, f.d)
+func (d *Decoder) fastpathDecSliceInt32R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]int32)
+		v, changed := fastpathTV.DecSliceInt32V(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
 		v := rv2i(rv).([]int32)
-		fastpathTV.DecSliceInt32V(v, fastpathCheckNilFalse, false, f.d)
+		v2, changed := fastpathTV.DecSliceInt32V(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceInt32X(vp *[]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceInt32V(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceInt32X(vp *[]int32, d *Decoder) {
+	v, changed := f.DecSliceInt32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceInt32V(v []int32, checkNil bool, canChange bool, d *Decoder) (_ []int32, changed bool) {
+func (_ fastpathT) DecSliceInt32V(v []int32, canChange bool, d *Decoder) (_ []int32, changed bool) {
 	dd := d.d
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -19377,7 +17485,6 @@ func (_ fastpathT) DecSliceInt32V(v []int32, checkNil bool, canChange bool, d *D
 		slh.End()
 		return v, changed
 	}
-
 	hasLen := containerLenS > 0
 	var xlen int
 	if hasLen && canChange {
@@ -19396,7 +17503,7 @@ func (_ fastpathT) DecSliceInt32V(v []int32, checkNil bool, canChange bool, d *D
 	}
 	j := 0
 	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
-		if j == 0 && len(v) == 0 {
+		if j == 0 && len(v) == 0 && canChange {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
 			} else {
@@ -19419,6 +17526,8 @@ func (_ fastpathT) DecSliceInt32V(v []int32, checkNil bool, canChange bool, d *D
 		slh.ElemContainerState(j)
 		if decodeIntoBlank {
 			d.swallow()
+		} else if dd.TryDecodeAsNil() {
+			v[j] = 0
 		} else {
 			v[j] = int32(dd.DecodeInt(32))
 		}
@@ -19436,35 +17545,29 @@ func (_ fastpathT) DecSliceInt32V(v []int32, checkNil bool, canChange bool, d *D
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceInt64R(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*[]int64)
-		v, changed := fastpathTV.DecSliceInt64V(*vp, fastpathCheckNilFalse, !array, f.d)
+func (d *Decoder) fastpathDecSliceInt64R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]int64)
+		v, changed := fastpathTV.DecSliceInt64V(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
 		v := rv2i(rv).([]int64)
-		fastpathTV.DecSliceInt64V(v, fastpathCheckNilFalse, false, f.d)
+		v2, changed := fastpathTV.DecSliceInt64V(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceInt64X(vp *[]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceInt64V(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceInt64X(vp *[]int64, d *Decoder) {
+	v, changed := f.DecSliceInt64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceInt64V(v []int64, checkNil bool, canChange bool, d *Decoder) (_ []int64, changed bool) {
+func (_ fastpathT) DecSliceInt64V(v []int64, canChange bool, d *Decoder) (_ []int64, changed bool) {
 	dd := d.d
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -19478,7 +17581,6 @@ func (_ fastpathT) DecSliceInt64V(v []int64, checkNil bool, canChange bool, d *D
 		slh.End()
 		return v, changed
 	}
-
 	hasLen := containerLenS > 0
 	var xlen int
 	if hasLen && canChange {
@@ -19497,7 +17599,7 @@ func (_ fastpathT) DecSliceInt64V(v []int64, checkNil bool, canChange bool, d *D
 	}
 	j := 0
 	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
-		if j == 0 && len(v) == 0 {
+		if j == 0 && len(v) == 0 && canChange {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
 			} else {
@@ -19520,6 +17622,8 @@ func (_ fastpathT) DecSliceInt64V(v []int64, checkNil bool, canChange bool, d *D
 		slh.ElemContainerState(j)
 		if decodeIntoBlank {
 			d.swallow()
+		} else if dd.TryDecodeAsNil() {
+			v[j] = 0
 		} else {
 			v[j] = dd.DecodeInt(64)
 		}
@@ -19537,35 +17641,29 @@ func (_ fastpathT) DecSliceInt64V(v []int64, checkNil bool, canChange bool, d *D
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecSliceBoolR(rv reflect.Value) {
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*[]bool)
-		v, changed := fastpathTV.DecSliceBoolV(*vp, fastpathCheckNilFalse, !array, f.d)
+func (d *Decoder) fastpathDecSliceBoolR(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]bool)
+		v, changed := fastpathTV.DecSliceBoolV(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
 		v := rv2i(rv).([]bool)
-		fastpathTV.DecSliceBoolV(v, fastpathCheckNilFalse, false, f.d)
+		v2, changed := fastpathTV.DecSliceBoolV(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceBoolX(vp *[]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceBoolV(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceBoolX(vp *[]bool, d *Decoder) {
+	v, changed := f.DecSliceBoolV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceBoolV(v []bool, checkNil bool, canChange bool, d *Decoder) (_ []bool, changed bool) {
+func (_ fastpathT) DecSliceBoolV(v []bool, canChange bool, d *Decoder) (_ []bool, changed bool) {
 	dd := d.d
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -19579,7 +17677,6 @@ func (_ fastpathT) DecSliceBoolV(v []bool, checkNil bool, canChange bool, d *Dec
 		slh.End()
 		return v, changed
 	}
-
 	hasLen := containerLenS > 0
 	var xlen int
 	if hasLen && canChange {
@@ -19598,7 +17695,7 @@ func (_ fastpathT) DecSliceBoolV(v []bool, checkNil bool, canChange bool, d *Dec
 	}
 	j := 0
 	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
-		if j == 0 && len(v) == 0 {
+		if j == 0 && len(v) == 0 && canChange {
 			if hasLen {
 				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
 			} else {
@@ -19621,6 +17718,8 @@ func (_ fastpathT) DecSliceBoolV(v []bool, checkNil bool, canChange bool, d *Dec
 		slh.ElemContainerState(j)
 		if decodeIntoBlank {
 			d.swallow()
+		} else if dd.TryDecodeAsNil() {
+			v[j] = false
 		} else {
 			v[j] = dd.DecodeBool()
 		}
@@ -19638,35 +17737,26 @@ func (_ fastpathT) DecSliceBoolV(v []bool, checkNil bool, canChange bool, d *Dec
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfIntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[interface{}]interface{})
-		v, changed := fastpathTV.DecMapIntfIntfV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntfIntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]interface{})
+		v, changed := fastpathTV.DecMapIntfIntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[interface{}]interface{})
-		fastpathTV.DecMapIntfIntfV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntfIntfV(rv2i(rv).(map[interface{}]interface{}), false, d)
 	}
 }
-func (f fastpathT) DecMapIntfIntfX(vp *map[interface{}]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfIntfV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntfIntfX(vp *map[interface{}]interface{}, d *Decoder) {
+	v, changed := f.DecMapIntfIntfV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfIntfV(v map[interface{}]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfIntfV(v map[interface{}]interface{}, canChange bool,
 	d *Decoder) (_ map[interface{}]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 32)
@@ -19674,26 +17764,33 @@ func (_ fastpathT) DecMapIntfIntfV(v map[interface{}]interface{}, checkNil bool,
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk interface{}
 	var mv interface{}
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = nil
 		d.decode(&mk)
 		if bv, bok := mk.([]byte); bok {
 			mk = d.string(bv)
 		}
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = nil
+			}
+			continue
 		}
 		if mapGet {
 			mv = v[mk]
@@ -19705,41 +17802,30 @@ func (_ fastpathT) DecMapIntfIntfV(v map[interface{}]interface{}, checkNil bool,
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfStringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[interface{}]string)
-		v, changed := fastpathTV.DecMapIntfStringV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntfStringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]string)
+		v, changed := fastpathTV.DecMapIntfStringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[interface{}]string)
-		fastpathTV.DecMapIntfStringV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntfStringV(rv2i(rv).(map[interface{}]string), false, d)
 	}
 }
-func (f fastpathT) DecMapIntfStringX(vp *map[interface{}]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfStringV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntfStringX(vp *map[interface{}]string, d *Decoder) {
+	v, changed := f.DecMapIntfStringV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfStringV(v map[interface{}]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfStringV(v map[interface{}]string, canChange bool,
 	d *Decoder) (_ map[interface{}]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 32)
@@ -19747,67 +17833,62 @@ func (_ fastpathT) DecMapIntfStringV(v map[interface{}]string, checkNil bool, ca
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk interface{}
 	var mv string
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = nil
 		d.decode(&mk)
 		if bv, bok := mk.([]byte); bok {
 			mk = d.string(bv)
 		}
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
+			}
+			continue
 		}
 		mv = dd.DecodeString()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfUintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[interface{}]uint)
-		v, changed := fastpathTV.DecMapIntfUintV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntfUintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]uint)
+		v, changed := fastpathTV.DecMapIntfUintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[interface{}]uint)
-		fastpathTV.DecMapIntfUintV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntfUintV(rv2i(rv).(map[interface{}]uint), false, d)
 	}
 }
-func (f fastpathT) DecMapIntfUintX(vp *map[interface{}]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfUintV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntfUintX(vp *map[interface{}]uint, d *Decoder) {
+	v, changed := f.DecMapIntfUintV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfUintV(v map[interface{}]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfUintV(v map[interface{}]uint, canChange bool,
 	d *Decoder) (_ map[interface{}]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -19815,67 +17896,62 @@ func (_ fastpathT) DecMapIntfUintV(v map[interface{}]uint, checkNil bool, canCha
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk interface{}
 	var mv uint
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = nil
 		d.decode(&mk)
 		if bv, bok := mk.([]byte); bok {
 			mk = d.string(bv)
 		}
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfUint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[interface{}]uint8)
-		v, changed := fastpathTV.DecMapIntfUint8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntfUint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]uint8)
+		v, changed := fastpathTV.DecMapIntfUint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[interface{}]uint8)
-		fastpathTV.DecMapIntfUint8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntfUint8V(rv2i(rv).(map[interface{}]uint8), false, d)
 	}
 }
-func (f fastpathT) DecMapIntfUint8X(vp *map[interface{}]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfUint8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntfUint8X(vp *map[interface{}]uint8, d *Decoder) {
+	v, changed := f.DecMapIntfUint8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfUint8V(v map[interface{}]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfUint8V(v map[interface{}]uint8, canChange bool,
 	d *Decoder) (_ map[interface{}]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
@@ -19883,67 +17959,62 @@ func (_ fastpathT) DecMapIntfUint8V(v map[interface{}]uint8, checkNil bool, canC
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk interface{}
 	var mv uint8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = nil
 		d.decode(&mk)
 		if bv, bok := mk.([]byte); bok {
 			mk = d.string(bv)
 		}
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint8(dd.DecodeUint(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfUint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[interface{}]uint16)
-		v, changed := fastpathTV.DecMapIntfUint16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntfUint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]uint16)
+		v, changed := fastpathTV.DecMapIntfUint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[interface{}]uint16)
-		fastpathTV.DecMapIntfUint16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntfUint16V(rv2i(rv).(map[interface{}]uint16), false, d)
 	}
 }
-func (f fastpathT) DecMapIntfUint16X(vp *map[interface{}]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfUint16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntfUint16X(vp *map[interface{}]uint16, d *Decoder) {
+	v, changed := f.DecMapIntfUint16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfUint16V(v map[interface{}]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfUint16V(v map[interface{}]uint16, canChange bool,
 	d *Decoder) (_ map[interface{}]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
@@ -19951,67 +18022,62 @@ func (_ fastpathT) DecMapIntfUint16V(v map[interface{}]uint16, checkNil bool, ca
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk interface{}
 	var mv uint16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = nil
 		d.decode(&mk)
 		if bv, bok := mk.([]byte); bok {
 			mk = d.string(bv)
 		}
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint16(dd.DecodeUint(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfUint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[interface{}]uint32)
-		v, changed := fastpathTV.DecMapIntfUint32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntfUint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]uint32)
+		v, changed := fastpathTV.DecMapIntfUint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[interface{}]uint32)
-		fastpathTV.DecMapIntfUint32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntfUint32V(rv2i(rv).(map[interface{}]uint32), false, d)
 	}
 }
-func (f fastpathT) DecMapIntfUint32X(vp *map[interface{}]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfUint32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntfUint32X(vp *map[interface{}]uint32, d *Decoder) {
+	v, changed := f.DecMapIntfUint32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfUint32V(v map[interface{}]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfUint32V(v map[interface{}]uint32, canChange bool,
 	d *Decoder) (_ map[interface{}]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
@@ -20019,67 +18085,62 @@ func (_ fastpathT) DecMapIntfUint32V(v map[interface{}]uint32, checkNil bool, ca
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk interface{}
 	var mv uint32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = nil
 		d.decode(&mk)
 		if bv, bok := mk.([]byte); bok {
 			mk = d.string(bv)
 		}
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint32(dd.DecodeUint(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfUint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[interface{}]uint64)
-		v, changed := fastpathTV.DecMapIntfUint64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntfUint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]uint64)
+		v, changed := fastpathTV.DecMapIntfUint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[interface{}]uint64)
-		fastpathTV.DecMapIntfUint64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntfUint64V(rv2i(rv).(map[interface{}]uint64), false, d)
 	}
 }
-func (f fastpathT) DecMapIntfUint64X(vp *map[interface{}]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfUint64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntfUint64X(vp *map[interface{}]uint64, d *Decoder) {
+	v, changed := f.DecMapIntfUint64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfUint64V(v map[interface{}]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfUint64V(v map[interface{}]uint64, canChange bool,
 	d *Decoder) (_ map[interface{}]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -20087,67 +18148,62 @@ func (_ fastpathT) DecMapIntfUint64V(v map[interface{}]uint64, checkNil bool, ca
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk interface{}
 	var mv uint64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = nil
 		d.decode(&mk)
 		if bv, bok := mk.([]byte); bok {
 			mk = d.string(bv)
 		}
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeUint(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfUintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[interface{}]uintptr)
-		v, changed := fastpathTV.DecMapIntfUintptrV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntfUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]uintptr)
+		v, changed := fastpathTV.DecMapIntfUintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[interface{}]uintptr)
-		fastpathTV.DecMapIntfUintptrV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntfUintptrV(rv2i(rv).(map[interface{}]uintptr), false, d)
 	}
 }
-func (f fastpathT) DecMapIntfUintptrX(vp *map[interface{}]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfUintptrV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntfUintptrX(vp *map[interface{}]uintptr, d *Decoder) {
+	v, changed := f.DecMapIntfUintptrV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfUintptrV(v map[interface{}]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfUintptrV(v map[interface{}]uintptr, canChange bool,
 	d *Decoder) (_ map[interface{}]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -20155,67 +18211,62 @@ func (_ fastpathT) DecMapIntfUintptrV(v map[interface{}]uintptr, checkNil bool,
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk interface{}
 	var mv uintptr
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = nil
 		d.decode(&mk)
 		if bv, bok := mk.([]byte); bok {
 			mk = d.string(bv)
 		}
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uintptr(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfIntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[interface{}]int)
-		v, changed := fastpathTV.DecMapIntfIntV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntfIntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]int)
+		v, changed := fastpathTV.DecMapIntfIntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[interface{}]int)
-		fastpathTV.DecMapIntfIntV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntfIntV(rv2i(rv).(map[interface{}]int), false, d)
 	}
 }
-func (f fastpathT) DecMapIntfIntX(vp *map[interface{}]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfIntV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntfIntX(vp *map[interface{}]int, d *Decoder) {
+	v, changed := f.DecMapIntfIntV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfIntV(v map[interface{}]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfIntV(v map[interface{}]int, canChange bool,
 	d *Decoder) (_ map[interface{}]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -20223,67 +18274,62 @@ func (_ fastpathT) DecMapIntfIntV(v map[interface{}]int, checkNil bool, canChang
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk interface{}
 	var mv int
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = nil
 		d.decode(&mk)
 		if bv, bok := mk.([]byte); bok {
 			mk = d.string(bv)
 		}
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int(dd.DecodeInt(intBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfInt8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[interface{}]int8)
-		v, changed := fastpathTV.DecMapIntfInt8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntfInt8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]int8)
+		v, changed := fastpathTV.DecMapIntfInt8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[interface{}]int8)
-		fastpathTV.DecMapIntfInt8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntfInt8V(rv2i(rv).(map[interface{}]int8), false, d)
 	}
 }
-func (f fastpathT) DecMapIntfInt8X(vp *map[interface{}]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfInt8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntfInt8X(vp *map[interface{}]int8, d *Decoder) {
+	v, changed := f.DecMapIntfInt8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfInt8V(v map[interface{}]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfInt8V(v map[interface{}]int8, canChange bool,
 	d *Decoder) (_ map[interface{}]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
@@ -20291,67 +18337,62 @@ func (_ fastpathT) DecMapIntfInt8V(v map[interface{}]int8, checkNil bool, canCha
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk interface{}
 	var mv int8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = nil
 		d.decode(&mk)
 		if bv, bok := mk.([]byte); bok {
 			mk = d.string(bv)
 		}
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int8(dd.DecodeInt(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfInt16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[interface{}]int16)
-		v, changed := fastpathTV.DecMapIntfInt16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntfInt16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]int16)
+		v, changed := fastpathTV.DecMapIntfInt16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[interface{}]int16)
-		fastpathTV.DecMapIntfInt16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntfInt16V(rv2i(rv).(map[interface{}]int16), false, d)
 	}
 }
-func (f fastpathT) DecMapIntfInt16X(vp *map[interface{}]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfInt16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntfInt16X(vp *map[interface{}]int16, d *Decoder) {
+	v, changed := f.DecMapIntfInt16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfInt16V(v map[interface{}]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfInt16V(v map[interface{}]int16, canChange bool,
 	d *Decoder) (_ map[interface{}]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
@@ -20359,67 +18400,62 @@ func (_ fastpathT) DecMapIntfInt16V(v map[interface{}]int16, checkNil bool, canC
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk interface{}
 	var mv int16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = nil
 		d.decode(&mk)
 		if bv, bok := mk.([]byte); bok {
 			mk = d.string(bv)
 		}
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int16(dd.DecodeInt(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfInt32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[interface{}]int32)
-		v, changed := fastpathTV.DecMapIntfInt32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntfInt32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]int32)
+		v, changed := fastpathTV.DecMapIntfInt32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[interface{}]int32)
-		fastpathTV.DecMapIntfInt32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntfInt32V(rv2i(rv).(map[interface{}]int32), false, d)
 	}
 }
-func (f fastpathT) DecMapIntfInt32X(vp *map[interface{}]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfInt32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntfInt32X(vp *map[interface{}]int32, d *Decoder) {
+	v, changed := f.DecMapIntfInt32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfInt32V(v map[interface{}]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfInt32V(v map[interface{}]int32, canChange bool,
 	d *Decoder) (_ map[interface{}]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
@@ -20427,67 +18463,62 @@ func (_ fastpathT) DecMapIntfInt32V(v map[interface{}]int32, checkNil bool, canC
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk interface{}
 	var mv int32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = nil
 		d.decode(&mk)
 		if bv, bok := mk.([]byte); bok {
 			mk = d.string(bv)
 		}
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int32(dd.DecodeInt(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfInt64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[interface{}]int64)
-		v, changed := fastpathTV.DecMapIntfInt64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntfInt64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]int64)
+		v, changed := fastpathTV.DecMapIntfInt64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[interface{}]int64)
-		fastpathTV.DecMapIntfInt64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntfInt64V(rv2i(rv).(map[interface{}]int64), false, d)
 	}
 }
-func (f fastpathT) DecMapIntfInt64X(vp *map[interface{}]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfInt64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntfInt64X(vp *map[interface{}]int64, d *Decoder) {
+	v, changed := f.DecMapIntfInt64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfInt64V(v map[interface{}]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfInt64V(v map[interface{}]int64, canChange bool,
 	d *Decoder) (_ map[interface{}]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -20495,67 +18526,62 @@ func (_ fastpathT) DecMapIntfInt64V(v map[interface{}]int64, checkNil bool, canC
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk interface{}
 	var mv int64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = nil
 		d.decode(&mk)
 		if bv, bok := mk.([]byte); bok {
 			mk = d.string(bv)
 		}
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeInt(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfFloat32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[interface{}]float32)
-		v, changed := fastpathTV.DecMapIntfFloat32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntfFloat32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]float32)
+		v, changed := fastpathTV.DecMapIntfFloat32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[interface{}]float32)
-		fastpathTV.DecMapIntfFloat32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntfFloat32V(rv2i(rv).(map[interface{}]float32), false, d)
 	}
 }
-func (f fastpathT) DecMapIntfFloat32X(vp *map[interface{}]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfFloat32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntfFloat32X(vp *map[interface{}]float32, d *Decoder) {
+	v, changed := f.DecMapIntfFloat32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfFloat32V(v map[interface{}]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfFloat32V(v map[interface{}]float32, canChange bool,
 	d *Decoder) (_ map[interface{}]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
@@ -20563,67 +18589,62 @@ func (_ fastpathT) DecMapIntfFloat32V(v map[interface{}]float32, checkNil bool,
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk interface{}
 	var mv float32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = nil
 		d.decode(&mk)
 		if bv, bok := mk.([]byte); bok {
 			mk = d.string(bv)
 		}
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = float32(dd.DecodeFloat(true))
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = float32(chkFloat32(dd.DecodeFloat64()))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfFloat64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[interface{}]float64)
-		v, changed := fastpathTV.DecMapIntfFloat64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntfFloat64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]float64)
+		v, changed := fastpathTV.DecMapIntfFloat64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[interface{}]float64)
-		fastpathTV.DecMapIntfFloat64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntfFloat64V(rv2i(rv).(map[interface{}]float64), false, d)
 	}
 }
-func (f fastpathT) DecMapIntfFloat64X(vp *map[interface{}]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfFloat64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntfFloat64X(vp *map[interface{}]float64, d *Decoder) {
+	v, changed := f.DecMapIntfFloat64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfFloat64V(v map[interface{}]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfFloat64V(v map[interface{}]float64, canChange bool,
 	d *Decoder) (_ map[interface{}]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -20631,67 +18652,62 @@ func (_ fastpathT) DecMapIntfFloat64V(v map[interface{}]float64, checkNil bool,
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk interface{}
 	var mv float64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = nil
 		d.decode(&mk)
 		if bv, bok := mk.([]byte); bok {
 			mk = d.string(bv)
 		}
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = dd.DecodeFloat(false)
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntfBoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[interface{}]bool)
-		v, changed := fastpathTV.DecMapIntfBoolV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntfBoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]bool)
+		v, changed := fastpathTV.DecMapIntfBoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[interface{}]bool)
-		fastpathTV.DecMapIntfBoolV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntfBoolV(rv2i(rv).(map[interface{}]bool), false, d)
 	}
 }
-func (f fastpathT) DecMapIntfBoolX(vp *map[interface{}]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntfBoolV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntfBoolX(vp *map[interface{}]bool, d *Decoder) {
+	v, changed := f.DecMapIntfBoolV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntfBoolV(v map[interface{}]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntfBoolV(v map[interface{}]bool, canChange bool,
 	d *Decoder) (_ map[interface{}]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
@@ -20699,67 +18715,62 @@ func (_ fastpathT) DecMapIntfBoolV(v map[interface{}]bool, checkNil bool, canCha
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk interface{}
 	var mv bool
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = nil
 		d.decode(&mk)
 		if bv, bok := mk.([]byte); bok {
 			mk = d.string(bv)
 		}
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
+			}
+			continue
 		}
 		mv = dd.DecodeBool()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringIntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[string]interface{})
-		v, changed := fastpathTV.DecMapStringIntfV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapStringIntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]interface{})
+		v, changed := fastpathTV.DecMapStringIntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[string]interface{})
-		fastpathTV.DecMapStringIntfV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapStringIntfV(rv2i(rv).(map[string]interface{}), false, d)
 	}
 }
-func (f fastpathT) DecMapStringIntfX(vp *map[string]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringIntfV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapStringIntfX(vp *map[string]interface{}, d *Decoder) {
+	v, changed := f.DecMapStringIntfV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringIntfV(v map[string]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringIntfV(v map[string]interface{}, canChange bool,
 	d *Decoder) (_ map[string]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 32)
@@ -20767,22 +18778,29 @@ func (_ fastpathT) DecMapStringIntfV(v map[string]interface{}, checkNil bool, ca
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk string
 	var mv interface{}
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeString()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = nil
+			}
+			continue
 		}
 		if mapGet {
 			mv = v[mk]
@@ -20794,41 +18812,30 @@ func (_ fastpathT) DecMapStringIntfV(v map[string]interface{}, checkNil bool, ca
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringStringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[string]string)
-		v, changed := fastpathTV.DecMapStringStringV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapStringStringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]string)
+		v, changed := fastpathTV.DecMapStringStringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[string]string)
-		fastpathTV.DecMapStringStringV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapStringStringV(rv2i(rv).(map[string]string), false, d)
 	}
 }
-func (f fastpathT) DecMapStringStringX(vp *map[string]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringStringV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapStringStringX(vp *map[string]string, d *Decoder) {
+	v, changed := f.DecMapStringStringV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringStringV(v map[string]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringStringV(v map[string]string, canChange bool,
 	d *Decoder) (_ map[string]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 32)
@@ -20836,63 +18843,58 @@ func (_ fastpathT) DecMapStringStringV(v map[string]string, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk string
 	var mv string
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeString()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
+			}
+			continue
 		}
 		mv = dd.DecodeString()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringUintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[string]uint)
-		v, changed := fastpathTV.DecMapStringUintV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapStringUintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]uint)
+		v, changed := fastpathTV.DecMapStringUintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[string]uint)
-		fastpathTV.DecMapStringUintV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapStringUintV(rv2i(rv).(map[string]uint), false, d)
 	}
 }
-func (f fastpathT) DecMapStringUintX(vp *map[string]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringUintV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapStringUintX(vp *map[string]uint, d *Decoder) {
+	v, changed := f.DecMapStringUintV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringUintV(v map[string]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringUintV(v map[string]uint, canChange bool,
 	d *Decoder) (_ map[string]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -20900,63 +18902,58 @@ func (_ fastpathT) DecMapStringUintV(v map[string]uint, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk string
 	var mv uint
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeString()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringUint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[string]uint8)
-		v, changed := fastpathTV.DecMapStringUint8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapStringUint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]uint8)
+		v, changed := fastpathTV.DecMapStringUint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[string]uint8)
-		fastpathTV.DecMapStringUint8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapStringUint8V(rv2i(rv).(map[string]uint8), false, d)
 	}
 }
-func (f fastpathT) DecMapStringUint8X(vp *map[string]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringUint8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapStringUint8X(vp *map[string]uint8, d *Decoder) {
+	v, changed := f.DecMapStringUint8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringUint8V(v map[string]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringUint8V(v map[string]uint8, canChange bool,
 	d *Decoder) (_ map[string]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
@@ -20964,63 +18961,58 @@ func (_ fastpathT) DecMapStringUint8V(v map[string]uint8, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk string
 	var mv uint8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeString()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint8(dd.DecodeUint(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringUint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[string]uint16)
-		v, changed := fastpathTV.DecMapStringUint16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapStringUint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]uint16)
+		v, changed := fastpathTV.DecMapStringUint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[string]uint16)
-		fastpathTV.DecMapStringUint16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapStringUint16V(rv2i(rv).(map[string]uint16), false, d)
 	}
 }
-func (f fastpathT) DecMapStringUint16X(vp *map[string]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringUint16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapStringUint16X(vp *map[string]uint16, d *Decoder) {
+	v, changed := f.DecMapStringUint16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringUint16V(v map[string]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringUint16V(v map[string]uint16, canChange bool,
 	d *Decoder) (_ map[string]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
@@ -21028,63 +19020,58 @@ func (_ fastpathT) DecMapStringUint16V(v map[string]uint16, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk string
 	var mv uint16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeString()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint16(dd.DecodeUint(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringUint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[string]uint32)
-		v, changed := fastpathTV.DecMapStringUint32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapStringUint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]uint32)
+		v, changed := fastpathTV.DecMapStringUint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[string]uint32)
-		fastpathTV.DecMapStringUint32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapStringUint32V(rv2i(rv).(map[string]uint32), false, d)
 	}
 }
-func (f fastpathT) DecMapStringUint32X(vp *map[string]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringUint32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapStringUint32X(vp *map[string]uint32, d *Decoder) {
+	v, changed := f.DecMapStringUint32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringUint32V(v map[string]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringUint32V(v map[string]uint32, canChange bool,
 	d *Decoder) (_ map[string]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
@@ -21092,63 +19079,58 @@ func (_ fastpathT) DecMapStringUint32V(v map[string]uint32, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk string
 	var mv uint32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeString()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint32(dd.DecodeUint(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringUint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[string]uint64)
-		v, changed := fastpathTV.DecMapStringUint64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapStringUint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]uint64)
+		v, changed := fastpathTV.DecMapStringUint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[string]uint64)
-		fastpathTV.DecMapStringUint64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapStringUint64V(rv2i(rv).(map[string]uint64), false, d)
 	}
 }
-func (f fastpathT) DecMapStringUint64X(vp *map[string]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringUint64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapStringUint64X(vp *map[string]uint64, d *Decoder) {
+	v, changed := f.DecMapStringUint64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringUint64V(v map[string]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringUint64V(v map[string]uint64, canChange bool,
 	d *Decoder) (_ map[string]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -21156,63 +19138,58 @@ func (_ fastpathT) DecMapStringUint64V(v map[string]uint64, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk string
 	var mv uint64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeString()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeUint(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringUintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[string]uintptr)
-		v, changed := fastpathTV.DecMapStringUintptrV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapStringUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]uintptr)
+		v, changed := fastpathTV.DecMapStringUintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[string]uintptr)
-		fastpathTV.DecMapStringUintptrV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapStringUintptrV(rv2i(rv).(map[string]uintptr), false, d)
 	}
 }
-func (f fastpathT) DecMapStringUintptrX(vp *map[string]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringUintptrV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapStringUintptrX(vp *map[string]uintptr, d *Decoder) {
+	v, changed := f.DecMapStringUintptrV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringUintptrV(v map[string]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringUintptrV(v map[string]uintptr, canChange bool,
 	d *Decoder) (_ map[string]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -21220,63 +19197,58 @@ func (_ fastpathT) DecMapStringUintptrV(v map[string]uintptr, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk string
 	var mv uintptr
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeString()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uintptr(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringIntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[string]int)
-		v, changed := fastpathTV.DecMapStringIntV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapStringIntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]int)
+		v, changed := fastpathTV.DecMapStringIntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[string]int)
-		fastpathTV.DecMapStringIntV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapStringIntV(rv2i(rv).(map[string]int), false, d)
 	}
 }
-func (f fastpathT) DecMapStringIntX(vp *map[string]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringIntV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapStringIntX(vp *map[string]int, d *Decoder) {
+	v, changed := f.DecMapStringIntV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringIntV(v map[string]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringIntV(v map[string]int, canChange bool,
 	d *Decoder) (_ map[string]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -21284,63 +19256,58 @@ func (_ fastpathT) DecMapStringIntV(v map[string]int, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk string
 	var mv int
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeString()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int(dd.DecodeInt(intBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringInt8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[string]int8)
-		v, changed := fastpathTV.DecMapStringInt8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapStringInt8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]int8)
+		v, changed := fastpathTV.DecMapStringInt8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[string]int8)
-		fastpathTV.DecMapStringInt8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapStringInt8V(rv2i(rv).(map[string]int8), false, d)
 	}
 }
-func (f fastpathT) DecMapStringInt8X(vp *map[string]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringInt8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapStringInt8X(vp *map[string]int8, d *Decoder) {
+	v, changed := f.DecMapStringInt8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringInt8V(v map[string]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringInt8V(v map[string]int8, canChange bool,
 	d *Decoder) (_ map[string]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
@@ -21348,63 +19315,58 @@ func (_ fastpathT) DecMapStringInt8V(v map[string]int8, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk string
 	var mv int8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeString()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int8(dd.DecodeInt(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringInt16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[string]int16)
-		v, changed := fastpathTV.DecMapStringInt16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapStringInt16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]int16)
+		v, changed := fastpathTV.DecMapStringInt16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[string]int16)
-		fastpathTV.DecMapStringInt16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapStringInt16V(rv2i(rv).(map[string]int16), false, d)
 	}
 }
-func (f fastpathT) DecMapStringInt16X(vp *map[string]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringInt16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapStringInt16X(vp *map[string]int16, d *Decoder) {
+	v, changed := f.DecMapStringInt16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringInt16V(v map[string]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringInt16V(v map[string]int16, canChange bool,
 	d *Decoder) (_ map[string]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
@@ -21412,63 +19374,58 @@ func (_ fastpathT) DecMapStringInt16V(v map[string]int16, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk string
 	var mv int16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeString()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int16(dd.DecodeInt(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringInt32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[string]int32)
-		v, changed := fastpathTV.DecMapStringInt32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapStringInt32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]int32)
+		v, changed := fastpathTV.DecMapStringInt32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[string]int32)
-		fastpathTV.DecMapStringInt32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapStringInt32V(rv2i(rv).(map[string]int32), false, d)
 	}
 }
-func (f fastpathT) DecMapStringInt32X(vp *map[string]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringInt32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapStringInt32X(vp *map[string]int32, d *Decoder) {
+	v, changed := f.DecMapStringInt32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringInt32V(v map[string]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringInt32V(v map[string]int32, canChange bool,
 	d *Decoder) (_ map[string]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
@@ -21476,63 +19433,58 @@ func (_ fastpathT) DecMapStringInt32V(v map[string]int32, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk string
 	var mv int32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeString()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int32(dd.DecodeInt(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringInt64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[string]int64)
-		v, changed := fastpathTV.DecMapStringInt64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapStringInt64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]int64)
+		v, changed := fastpathTV.DecMapStringInt64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[string]int64)
-		fastpathTV.DecMapStringInt64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapStringInt64V(rv2i(rv).(map[string]int64), false, d)
 	}
 }
-func (f fastpathT) DecMapStringInt64X(vp *map[string]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringInt64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapStringInt64X(vp *map[string]int64, d *Decoder) {
+	v, changed := f.DecMapStringInt64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringInt64V(v map[string]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringInt64V(v map[string]int64, canChange bool,
 	d *Decoder) (_ map[string]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -21540,63 +19492,58 @@ func (_ fastpathT) DecMapStringInt64V(v map[string]int64, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk string
 	var mv int64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeString()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeInt(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringFloat32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[string]float32)
-		v, changed := fastpathTV.DecMapStringFloat32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapStringFloat32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]float32)
+		v, changed := fastpathTV.DecMapStringFloat32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[string]float32)
-		fastpathTV.DecMapStringFloat32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapStringFloat32V(rv2i(rv).(map[string]float32), false, d)
 	}
 }
-func (f fastpathT) DecMapStringFloat32X(vp *map[string]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringFloat32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapStringFloat32X(vp *map[string]float32, d *Decoder) {
+	v, changed := f.DecMapStringFloat32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringFloat32V(v map[string]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringFloat32V(v map[string]float32, canChange bool,
 	d *Decoder) (_ map[string]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
@@ -21604,63 +19551,58 @@ func (_ fastpathT) DecMapStringFloat32V(v map[string]float32, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk string
 	var mv float32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeString()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = float32(dd.DecodeFloat(true))
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = float32(chkFloat32(dd.DecodeFloat64()))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringFloat64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[string]float64)
-		v, changed := fastpathTV.DecMapStringFloat64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapStringFloat64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]float64)
+		v, changed := fastpathTV.DecMapStringFloat64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[string]float64)
-		fastpathTV.DecMapStringFloat64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapStringFloat64V(rv2i(rv).(map[string]float64), false, d)
 	}
 }
-func (f fastpathT) DecMapStringFloat64X(vp *map[string]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringFloat64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapStringFloat64X(vp *map[string]float64, d *Decoder) {
+	v, changed := f.DecMapStringFloat64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringFloat64V(v map[string]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringFloat64V(v map[string]float64, canChange bool,
 	d *Decoder) (_ map[string]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -21668,63 +19610,58 @@ func (_ fastpathT) DecMapStringFloat64V(v map[string]float64, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk string
 	var mv float64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeString()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = dd.DecodeFloat(false)
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapStringBoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[string]bool)
-		v, changed := fastpathTV.DecMapStringBoolV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapStringBoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]bool)
+		v, changed := fastpathTV.DecMapStringBoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[string]bool)
-		fastpathTV.DecMapStringBoolV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapStringBoolV(rv2i(rv).(map[string]bool), false, d)
 	}
 }
-func (f fastpathT) DecMapStringBoolX(vp *map[string]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapStringBoolV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapStringBoolX(vp *map[string]bool, d *Decoder) {
+	v, changed := f.DecMapStringBoolV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapStringBoolV(v map[string]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapStringBoolV(v map[string]bool, canChange bool,
 	d *Decoder) (_ map[string]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
@@ -21732,63 +19669,58 @@ func (_ fastpathT) DecMapStringBoolV(v map[string]bool, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk string
 	var mv bool
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeString()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
+			}
+			continue
 		}
 		mv = dd.DecodeBool()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32IntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float32]interface{})
-		v, changed := fastpathTV.DecMapFloat32IntfV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat32IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]interface{})
+		v, changed := fastpathTV.DecMapFloat32IntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float32]interface{})
-		fastpathTV.DecMapFloat32IntfV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat32IntfV(rv2i(rv).(map[float32]interface{}), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat32IntfX(vp *map[float32]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32IntfV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat32IntfX(vp *map[float32]interface{}, d *Decoder) {
+	v, changed := f.DecMapFloat32IntfV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32IntfV(v map[float32]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32IntfV(v map[float32]interface{}, canChange bool,
 	d *Decoder) (_ map[float32]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
@@ -21796,22 +19728,29 @@ func (_ fastpathT) DecMapFloat32IntfV(v map[float32]interface{}, checkNil bool,
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk float32
 	var mv interface{}
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = float32(dd.DecodeFloat(true))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = float32(chkFloat32(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = nil
+			}
+			continue
 		}
 		if mapGet {
 			mv = v[mk]
@@ -21823,41 +19762,30 @@ func (_ fastpathT) DecMapFloat32IntfV(v map[float32]interface{}, checkNil bool,
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32StringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float32]string)
-		v, changed := fastpathTV.DecMapFloat32StringV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat32StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]string)
+		v, changed := fastpathTV.DecMapFloat32StringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float32]string)
-		fastpathTV.DecMapFloat32StringV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat32StringV(rv2i(rv).(map[float32]string), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat32StringX(vp *map[float32]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32StringV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat32StringX(vp *map[float32]string, d *Decoder) {
+	v, changed := f.DecMapFloat32StringV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32StringV(v map[float32]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32StringV(v map[float32]string, canChange bool,
 	d *Decoder) (_ map[float32]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
@@ -21865,63 +19793,58 @@ func (_ fastpathT) DecMapFloat32StringV(v map[float32]string, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float32
 	var mv string
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = float32(dd.DecodeFloat(true))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = float32(chkFloat32(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
+			}
+			continue
 		}
 		mv = dd.DecodeString()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32UintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float32]uint)
-		v, changed := fastpathTV.DecMapFloat32UintV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat32UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]uint)
+		v, changed := fastpathTV.DecMapFloat32UintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float32]uint)
-		fastpathTV.DecMapFloat32UintV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat32UintV(rv2i(rv).(map[float32]uint), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat32UintX(vp *map[float32]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32UintV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat32UintX(vp *map[float32]uint, d *Decoder) {
+	v, changed := f.DecMapFloat32UintV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32UintV(v map[float32]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32UintV(v map[float32]uint, canChange bool,
 	d *Decoder) (_ map[float32]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -21929,63 +19852,58 @@ func (_ fastpathT) DecMapFloat32UintV(v map[float32]uint, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float32
 	var mv uint
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = float32(dd.DecodeFloat(true))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = float32(chkFloat32(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32Uint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float32]uint8)
-		v, changed := fastpathTV.DecMapFloat32Uint8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat32Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]uint8)
+		v, changed := fastpathTV.DecMapFloat32Uint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float32]uint8)
-		fastpathTV.DecMapFloat32Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat32Uint8V(rv2i(rv).(map[float32]uint8), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat32Uint8X(vp *map[float32]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32Uint8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat32Uint8X(vp *map[float32]uint8, d *Decoder) {
+	v, changed := f.DecMapFloat32Uint8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32Uint8V(v map[float32]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32Uint8V(v map[float32]uint8, canChange bool,
 	d *Decoder) (_ map[float32]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
@@ -21993,63 +19911,58 @@ func (_ fastpathT) DecMapFloat32Uint8V(v map[float32]uint8, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float32
 	var mv uint8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = float32(dd.DecodeFloat(true))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = float32(chkFloat32(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint8(dd.DecodeUint(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32Uint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float32]uint16)
-		v, changed := fastpathTV.DecMapFloat32Uint16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat32Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]uint16)
+		v, changed := fastpathTV.DecMapFloat32Uint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float32]uint16)
-		fastpathTV.DecMapFloat32Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat32Uint16V(rv2i(rv).(map[float32]uint16), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat32Uint16X(vp *map[float32]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32Uint16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat32Uint16X(vp *map[float32]uint16, d *Decoder) {
+	v, changed := f.DecMapFloat32Uint16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32Uint16V(v map[float32]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32Uint16V(v map[float32]uint16, canChange bool,
 	d *Decoder) (_ map[float32]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
@@ -22057,63 +19970,58 @@ func (_ fastpathT) DecMapFloat32Uint16V(v map[float32]uint16, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float32
 	var mv uint16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = float32(dd.DecodeFloat(true))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = float32(chkFloat32(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint16(dd.DecodeUint(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32Uint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float32]uint32)
-		v, changed := fastpathTV.DecMapFloat32Uint32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat32Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]uint32)
+		v, changed := fastpathTV.DecMapFloat32Uint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float32]uint32)
-		fastpathTV.DecMapFloat32Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat32Uint32V(rv2i(rv).(map[float32]uint32), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat32Uint32X(vp *map[float32]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32Uint32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat32Uint32X(vp *map[float32]uint32, d *Decoder) {
+	v, changed := f.DecMapFloat32Uint32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32Uint32V(v map[float32]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32Uint32V(v map[float32]uint32, canChange bool,
 	d *Decoder) (_ map[float32]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
@@ -22121,63 +20029,58 @@ func (_ fastpathT) DecMapFloat32Uint32V(v map[float32]uint32, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float32
 	var mv uint32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = float32(dd.DecodeFloat(true))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = float32(chkFloat32(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint32(dd.DecodeUint(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32Uint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float32]uint64)
-		v, changed := fastpathTV.DecMapFloat32Uint64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat32Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]uint64)
+		v, changed := fastpathTV.DecMapFloat32Uint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float32]uint64)
-		fastpathTV.DecMapFloat32Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat32Uint64V(rv2i(rv).(map[float32]uint64), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat32Uint64X(vp *map[float32]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32Uint64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat32Uint64X(vp *map[float32]uint64, d *Decoder) {
+	v, changed := f.DecMapFloat32Uint64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32Uint64V(v map[float32]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32Uint64V(v map[float32]uint64, canChange bool,
 	d *Decoder) (_ map[float32]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -22185,63 +20088,58 @@ func (_ fastpathT) DecMapFloat32Uint64V(v map[float32]uint64, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float32
 	var mv uint64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = float32(dd.DecodeFloat(true))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = float32(chkFloat32(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeUint(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32UintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float32]uintptr)
-		v, changed := fastpathTV.DecMapFloat32UintptrV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat32UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]uintptr)
+		v, changed := fastpathTV.DecMapFloat32UintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float32]uintptr)
-		fastpathTV.DecMapFloat32UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat32UintptrV(rv2i(rv).(map[float32]uintptr), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat32UintptrX(vp *map[float32]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32UintptrV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat32UintptrX(vp *map[float32]uintptr, d *Decoder) {
+	v, changed := f.DecMapFloat32UintptrV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32UintptrV(v map[float32]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32UintptrV(v map[float32]uintptr, canChange bool,
 	d *Decoder) (_ map[float32]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -22249,63 +20147,58 @@ func (_ fastpathT) DecMapFloat32UintptrV(v map[float32]uintptr, checkNil bool, c
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float32
 	var mv uintptr
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = float32(dd.DecodeFloat(true))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = float32(chkFloat32(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uintptr(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32IntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float32]int)
-		v, changed := fastpathTV.DecMapFloat32IntV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat32IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]int)
+		v, changed := fastpathTV.DecMapFloat32IntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float32]int)
-		fastpathTV.DecMapFloat32IntV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat32IntV(rv2i(rv).(map[float32]int), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat32IntX(vp *map[float32]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32IntV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat32IntX(vp *map[float32]int, d *Decoder) {
+	v, changed := f.DecMapFloat32IntV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32IntV(v map[float32]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32IntV(v map[float32]int, canChange bool,
 	d *Decoder) (_ map[float32]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -22313,63 +20206,58 @@ func (_ fastpathT) DecMapFloat32IntV(v map[float32]int, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float32
 	var mv int
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = float32(dd.DecodeFloat(true))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = float32(chkFloat32(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int(dd.DecodeInt(intBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32Int8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float32]int8)
-		v, changed := fastpathTV.DecMapFloat32Int8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat32Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]int8)
+		v, changed := fastpathTV.DecMapFloat32Int8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float32]int8)
-		fastpathTV.DecMapFloat32Int8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat32Int8V(rv2i(rv).(map[float32]int8), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat32Int8X(vp *map[float32]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32Int8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat32Int8X(vp *map[float32]int8, d *Decoder) {
+	v, changed := f.DecMapFloat32Int8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32Int8V(v map[float32]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32Int8V(v map[float32]int8, canChange bool,
 	d *Decoder) (_ map[float32]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
@@ -22377,63 +20265,58 @@ func (_ fastpathT) DecMapFloat32Int8V(v map[float32]int8, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float32
 	var mv int8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = float32(dd.DecodeFloat(true))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = float32(chkFloat32(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int8(dd.DecodeInt(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32Int16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float32]int16)
-		v, changed := fastpathTV.DecMapFloat32Int16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat32Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]int16)
+		v, changed := fastpathTV.DecMapFloat32Int16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float32]int16)
-		fastpathTV.DecMapFloat32Int16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat32Int16V(rv2i(rv).(map[float32]int16), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat32Int16X(vp *map[float32]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32Int16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat32Int16X(vp *map[float32]int16, d *Decoder) {
+	v, changed := f.DecMapFloat32Int16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32Int16V(v map[float32]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32Int16V(v map[float32]int16, canChange bool,
 	d *Decoder) (_ map[float32]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
@@ -22441,63 +20324,58 @@ func (_ fastpathT) DecMapFloat32Int16V(v map[float32]int16, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float32
 	var mv int16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = float32(dd.DecodeFloat(true))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = float32(chkFloat32(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int16(dd.DecodeInt(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32Int32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float32]int32)
-		v, changed := fastpathTV.DecMapFloat32Int32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat32Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]int32)
+		v, changed := fastpathTV.DecMapFloat32Int32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float32]int32)
-		fastpathTV.DecMapFloat32Int32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat32Int32V(rv2i(rv).(map[float32]int32), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat32Int32X(vp *map[float32]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32Int32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat32Int32X(vp *map[float32]int32, d *Decoder) {
+	v, changed := f.DecMapFloat32Int32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32Int32V(v map[float32]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32Int32V(v map[float32]int32, canChange bool,
 	d *Decoder) (_ map[float32]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
@@ -22505,63 +20383,58 @@ func (_ fastpathT) DecMapFloat32Int32V(v map[float32]int32, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float32
 	var mv int32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = float32(dd.DecodeFloat(true))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = float32(chkFloat32(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int32(dd.DecodeInt(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32Int64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float32]int64)
-		v, changed := fastpathTV.DecMapFloat32Int64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat32Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]int64)
+		v, changed := fastpathTV.DecMapFloat32Int64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float32]int64)
-		fastpathTV.DecMapFloat32Int64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat32Int64V(rv2i(rv).(map[float32]int64), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat32Int64X(vp *map[float32]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32Int64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat32Int64X(vp *map[float32]int64, d *Decoder) {
+	v, changed := f.DecMapFloat32Int64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32Int64V(v map[float32]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32Int64V(v map[float32]int64, canChange bool,
 	d *Decoder) (_ map[float32]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -22569,63 +20442,58 @@ func (_ fastpathT) DecMapFloat32Int64V(v map[float32]int64, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float32
 	var mv int64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = float32(dd.DecodeFloat(true))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = float32(chkFloat32(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeInt(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32Float32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float32]float32)
-		v, changed := fastpathTV.DecMapFloat32Float32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat32Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]float32)
+		v, changed := fastpathTV.DecMapFloat32Float32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float32]float32)
-		fastpathTV.DecMapFloat32Float32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat32Float32V(rv2i(rv).(map[float32]float32), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat32Float32X(vp *map[float32]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32Float32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat32Float32X(vp *map[float32]float32, d *Decoder) {
+	v, changed := f.DecMapFloat32Float32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32Float32V(v map[float32]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32Float32V(v map[float32]float32, canChange bool,
 	d *Decoder) (_ map[float32]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
@@ -22633,63 +20501,58 @@ func (_ fastpathT) DecMapFloat32Float32V(v map[float32]float32, checkNil bool, c
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float32
 	var mv float32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = float32(dd.DecodeFloat(true))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = float32(chkFloat32(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = float32(dd.DecodeFloat(true))
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = float32(chkFloat32(dd.DecodeFloat64()))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32Float64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float32]float64)
-		v, changed := fastpathTV.DecMapFloat32Float64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat32Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]float64)
+		v, changed := fastpathTV.DecMapFloat32Float64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float32]float64)
-		fastpathTV.DecMapFloat32Float64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat32Float64V(rv2i(rv).(map[float32]float64), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat32Float64X(vp *map[float32]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32Float64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat32Float64X(vp *map[float32]float64, d *Decoder) {
+	v, changed := f.DecMapFloat32Float64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32Float64V(v map[float32]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32Float64V(v map[float32]float64, canChange bool,
 	d *Decoder) (_ map[float32]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -22697,63 +20560,58 @@ func (_ fastpathT) DecMapFloat32Float64V(v map[float32]float64, checkNil bool, c
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float32
 	var mv float64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = float32(dd.DecodeFloat(true))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = float32(chkFloat32(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = dd.DecodeFloat(false)
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat32BoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float32]bool)
-		v, changed := fastpathTV.DecMapFloat32BoolV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat32BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]bool)
+		v, changed := fastpathTV.DecMapFloat32BoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float32]bool)
-		fastpathTV.DecMapFloat32BoolV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat32BoolV(rv2i(rv).(map[float32]bool), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat32BoolX(vp *map[float32]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat32BoolV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat32BoolX(vp *map[float32]bool, d *Decoder) {
+	v, changed := f.DecMapFloat32BoolV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat32BoolV(v map[float32]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat32BoolV(v map[float32]bool, canChange bool,
 	d *Decoder) (_ map[float32]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
@@ -22761,63 +20619,58 @@ func (_ fastpathT) DecMapFloat32BoolV(v map[float32]bool, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float32
 	var mv bool
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = float32(dd.DecodeFloat(true))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = float32(chkFloat32(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
+			}
+			continue
 		}
 		mv = dd.DecodeBool()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64IntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float64]interface{})
-		v, changed := fastpathTV.DecMapFloat64IntfV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat64IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]interface{})
+		v, changed := fastpathTV.DecMapFloat64IntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float64]interface{})
-		fastpathTV.DecMapFloat64IntfV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat64IntfV(rv2i(rv).(map[float64]interface{}), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat64IntfX(vp *map[float64]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64IntfV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat64IntfX(vp *map[float64]interface{}, d *Decoder) {
+	v, changed := f.DecMapFloat64IntfV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64IntfV(v map[float64]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64IntfV(v map[float64]interface{}, canChange bool,
 	d *Decoder) (_ map[float64]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -22825,22 +20678,29 @@ func (_ fastpathT) DecMapFloat64IntfV(v map[float64]interface{}, checkNil bool,
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk float64
 	var mv interface{}
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = dd.DecodeFloat(false)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = dd.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = nil
+			}
+			continue
 		}
 		if mapGet {
 			mv = v[mk]
@@ -22852,41 +20712,30 @@ func (_ fastpathT) DecMapFloat64IntfV(v map[float64]interface{}, checkNil bool,
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64StringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float64]string)
-		v, changed := fastpathTV.DecMapFloat64StringV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat64StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]string)
+		v, changed := fastpathTV.DecMapFloat64StringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float64]string)
-		fastpathTV.DecMapFloat64StringV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat64StringV(rv2i(rv).(map[float64]string), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat64StringX(vp *map[float64]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64StringV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat64StringX(vp *map[float64]string, d *Decoder) {
+	v, changed := f.DecMapFloat64StringV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64StringV(v map[float64]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64StringV(v map[float64]string, canChange bool,
 	d *Decoder) (_ map[float64]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -22894,63 +20743,58 @@ func (_ fastpathT) DecMapFloat64StringV(v map[float64]string, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float64
 	var mv string
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = dd.DecodeFloat(false)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = dd.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
+			}
+			continue
 		}
 		mv = dd.DecodeString()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64UintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float64]uint)
-		v, changed := fastpathTV.DecMapFloat64UintV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat64UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]uint)
+		v, changed := fastpathTV.DecMapFloat64UintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float64]uint)
-		fastpathTV.DecMapFloat64UintV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat64UintV(rv2i(rv).(map[float64]uint), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat64UintX(vp *map[float64]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64UintV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat64UintX(vp *map[float64]uint, d *Decoder) {
+	v, changed := f.DecMapFloat64UintV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64UintV(v map[float64]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64UintV(v map[float64]uint, canChange bool,
 	d *Decoder) (_ map[float64]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -22958,63 +20802,58 @@ func (_ fastpathT) DecMapFloat64UintV(v map[float64]uint, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float64
 	var mv uint
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = dd.DecodeFloat(false)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = dd.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64Uint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float64]uint8)
-		v, changed := fastpathTV.DecMapFloat64Uint8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat64Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]uint8)
+		v, changed := fastpathTV.DecMapFloat64Uint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float64]uint8)
-		fastpathTV.DecMapFloat64Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat64Uint8V(rv2i(rv).(map[float64]uint8), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat64Uint8X(vp *map[float64]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64Uint8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat64Uint8X(vp *map[float64]uint8, d *Decoder) {
+	v, changed := f.DecMapFloat64Uint8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64Uint8V(v map[float64]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64Uint8V(v map[float64]uint8, canChange bool,
 	d *Decoder) (_ map[float64]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -23022,63 +20861,58 @@ func (_ fastpathT) DecMapFloat64Uint8V(v map[float64]uint8, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float64
 	var mv uint8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = dd.DecodeFloat(false)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = dd.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint8(dd.DecodeUint(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64Uint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float64]uint16)
-		v, changed := fastpathTV.DecMapFloat64Uint16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat64Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]uint16)
+		v, changed := fastpathTV.DecMapFloat64Uint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float64]uint16)
-		fastpathTV.DecMapFloat64Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat64Uint16V(rv2i(rv).(map[float64]uint16), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat64Uint16X(vp *map[float64]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64Uint16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat64Uint16X(vp *map[float64]uint16, d *Decoder) {
+	v, changed := f.DecMapFloat64Uint16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64Uint16V(v map[float64]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64Uint16V(v map[float64]uint16, canChange bool,
 	d *Decoder) (_ map[float64]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -23086,63 +20920,58 @@ func (_ fastpathT) DecMapFloat64Uint16V(v map[float64]uint16, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float64
 	var mv uint16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = dd.DecodeFloat(false)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = dd.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint16(dd.DecodeUint(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64Uint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float64]uint32)
-		v, changed := fastpathTV.DecMapFloat64Uint32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat64Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]uint32)
+		v, changed := fastpathTV.DecMapFloat64Uint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float64]uint32)
-		fastpathTV.DecMapFloat64Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat64Uint32V(rv2i(rv).(map[float64]uint32), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat64Uint32X(vp *map[float64]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64Uint32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat64Uint32X(vp *map[float64]uint32, d *Decoder) {
+	v, changed := f.DecMapFloat64Uint32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64Uint32V(v map[float64]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64Uint32V(v map[float64]uint32, canChange bool,
 	d *Decoder) (_ map[float64]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -23150,63 +20979,58 @@ func (_ fastpathT) DecMapFloat64Uint32V(v map[float64]uint32, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float64
 	var mv uint32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = dd.DecodeFloat(false)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = dd.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint32(dd.DecodeUint(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64Uint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float64]uint64)
-		v, changed := fastpathTV.DecMapFloat64Uint64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat64Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]uint64)
+		v, changed := fastpathTV.DecMapFloat64Uint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float64]uint64)
-		fastpathTV.DecMapFloat64Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat64Uint64V(rv2i(rv).(map[float64]uint64), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat64Uint64X(vp *map[float64]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64Uint64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat64Uint64X(vp *map[float64]uint64, d *Decoder) {
+	v, changed := f.DecMapFloat64Uint64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64Uint64V(v map[float64]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64Uint64V(v map[float64]uint64, canChange bool,
 	d *Decoder) (_ map[float64]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -23214,63 +21038,58 @@ func (_ fastpathT) DecMapFloat64Uint64V(v map[float64]uint64, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float64
 	var mv uint64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = dd.DecodeFloat(false)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = dd.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeUint(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64UintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float64]uintptr)
-		v, changed := fastpathTV.DecMapFloat64UintptrV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat64UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]uintptr)
+		v, changed := fastpathTV.DecMapFloat64UintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float64]uintptr)
-		fastpathTV.DecMapFloat64UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat64UintptrV(rv2i(rv).(map[float64]uintptr), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat64UintptrX(vp *map[float64]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64UintptrV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat64UintptrX(vp *map[float64]uintptr, d *Decoder) {
+	v, changed := f.DecMapFloat64UintptrV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64UintptrV(v map[float64]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64UintptrV(v map[float64]uintptr, canChange bool,
 	d *Decoder) (_ map[float64]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -23278,63 +21097,58 @@ func (_ fastpathT) DecMapFloat64UintptrV(v map[float64]uintptr, checkNil bool, c
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float64
 	var mv uintptr
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = dd.DecodeFloat(false)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = dd.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uintptr(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64IntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float64]int)
-		v, changed := fastpathTV.DecMapFloat64IntV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat64IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]int)
+		v, changed := fastpathTV.DecMapFloat64IntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float64]int)
-		fastpathTV.DecMapFloat64IntV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat64IntV(rv2i(rv).(map[float64]int), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat64IntX(vp *map[float64]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64IntV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat64IntX(vp *map[float64]int, d *Decoder) {
+	v, changed := f.DecMapFloat64IntV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64IntV(v map[float64]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64IntV(v map[float64]int, canChange bool,
 	d *Decoder) (_ map[float64]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -23342,63 +21156,58 @@ func (_ fastpathT) DecMapFloat64IntV(v map[float64]int, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float64
 	var mv int
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = dd.DecodeFloat(false)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = dd.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int(dd.DecodeInt(intBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64Int8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float64]int8)
-		v, changed := fastpathTV.DecMapFloat64Int8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat64Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]int8)
+		v, changed := fastpathTV.DecMapFloat64Int8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float64]int8)
-		fastpathTV.DecMapFloat64Int8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat64Int8V(rv2i(rv).(map[float64]int8), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat64Int8X(vp *map[float64]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64Int8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat64Int8X(vp *map[float64]int8, d *Decoder) {
+	v, changed := f.DecMapFloat64Int8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64Int8V(v map[float64]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64Int8V(v map[float64]int8, canChange bool,
 	d *Decoder) (_ map[float64]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -23406,63 +21215,58 @@ func (_ fastpathT) DecMapFloat64Int8V(v map[float64]int8, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float64
 	var mv int8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = dd.DecodeFloat(false)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = dd.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int8(dd.DecodeInt(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64Int16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float64]int16)
-		v, changed := fastpathTV.DecMapFloat64Int16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat64Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]int16)
+		v, changed := fastpathTV.DecMapFloat64Int16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float64]int16)
-		fastpathTV.DecMapFloat64Int16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat64Int16V(rv2i(rv).(map[float64]int16), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat64Int16X(vp *map[float64]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64Int16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat64Int16X(vp *map[float64]int16, d *Decoder) {
+	v, changed := f.DecMapFloat64Int16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64Int16V(v map[float64]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64Int16V(v map[float64]int16, canChange bool,
 	d *Decoder) (_ map[float64]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -23470,63 +21274,58 @@ func (_ fastpathT) DecMapFloat64Int16V(v map[float64]int16, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float64
 	var mv int16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = dd.DecodeFloat(false)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = dd.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int16(dd.DecodeInt(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64Int32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float64]int32)
-		v, changed := fastpathTV.DecMapFloat64Int32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat64Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]int32)
+		v, changed := fastpathTV.DecMapFloat64Int32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float64]int32)
-		fastpathTV.DecMapFloat64Int32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat64Int32V(rv2i(rv).(map[float64]int32), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat64Int32X(vp *map[float64]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64Int32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat64Int32X(vp *map[float64]int32, d *Decoder) {
+	v, changed := f.DecMapFloat64Int32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64Int32V(v map[float64]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64Int32V(v map[float64]int32, canChange bool,
 	d *Decoder) (_ map[float64]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -23534,63 +21333,58 @@ func (_ fastpathT) DecMapFloat64Int32V(v map[float64]int32, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float64
 	var mv int32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = dd.DecodeFloat(false)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = dd.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int32(dd.DecodeInt(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64Int64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float64]int64)
-		v, changed := fastpathTV.DecMapFloat64Int64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat64Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]int64)
+		v, changed := fastpathTV.DecMapFloat64Int64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float64]int64)
-		fastpathTV.DecMapFloat64Int64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat64Int64V(rv2i(rv).(map[float64]int64), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat64Int64X(vp *map[float64]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64Int64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat64Int64X(vp *map[float64]int64, d *Decoder) {
+	v, changed := f.DecMapFloat64Int64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64Int64V(v map[float64]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64Int64V(v map[float64]int64, canChange bool,
 	d *Decoder) (_ map[float64]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -23598,63 +21392,58 @@ func (_ fastpathT) DecMapFloat64Int64V(v map[float64]int64, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float64
 	var mv int64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = dd.DecodeFloat(false)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = dd.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeInt(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64Float32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float64]float32)
-		v, changed := fastpathTV.DecMapFloat64Float32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat64Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]float32)
+		v, changed := fastpathTV.DecMapFloat64Float32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float64]float32)
-		fastpathTV.DecMapFloat64Float32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat64Float32V(rv2i(rv).(map[float64]float32), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat64Float32X(vp *map[float64]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64Float32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat64Float32X(vp *map[float64]float32, d *Decoder) {
+	v, changed := f.DecMapFloat64Float32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64Float32V(v map[float64]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64Float32V(v map[float64]float32, canChange bool,
 	d *Decoder) (_ map[float64]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -23662,63 +21451,58 @@ func (_ fastpathT) DecMapFloat64Float32V(v map[float64]float32, checkNil bool, c
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float64
 	var mv float32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = dd.DecodeFloat(false)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = dd.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = float32(dd.DecodeFloat(true))
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = float32(chkFloat32(dd.DecodeFloat64()))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64Float64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float64]float64)
-		v, changed := fastpathTV.DecMapFloat64Float64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat64Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]float64)
+		v, changed := fastpathTV.DecMapFloat64Float64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float64]float64)
-		fastpathTV.DecMapFloat64Float64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat64Float64V(rv2i(rv).(map[float64]float64), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat64Float64X(vp *map[float64]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64Float64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat64Float64X(vp *map[float64]float64, d *Decoder) {
+	v, changed := f.DecMapFloat64Float64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64Float64V(v map[float64]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64Float64V(v map[float64]float64, canChange bool,
 	d *Decoder) (_ map[float64]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -23726,63 +21510,58 @@ func (_ fastpathT) DecMapFloat64Float64V(v map[float64]float64, checkNil bool, c
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float64
 	var mv float64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = dd.DecodeFloat(false)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = dd.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = dd.DecodeFloat(false)
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapFloat64BoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[float64]bool)
-		v, changed := fastpathTV.DecMapFloat64BoolV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapFloat64BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]bool)
+		v, changed := fastpathTV.DecMapFloat64BoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[float64]bool)
-		fastpathTV.DecMapFloat64BoolV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapFloat64BoolV(rv2i(rv).(map[float64]bool), false, d)
 	}
 }
-func (f fastpathT) DecMapFloat64BoolX(vp *map[float64]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapFloat64BoolV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapFloat64BoolX(vp *map[float64]bool, d *Decoder) {
+	v, changed := f.DecMapFloat64BoolV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapFloat64BoolV(v map[float64]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapFloat64BoolV(v map[float64]bool, canChange bool,
 	d *Decoder) (_ map[float64]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -23790,63 +21569,58 @@ func (_ fastpathT) DecMapFloat64BoolV(v map[float64]bool, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk float64
 	var mv bool
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
-		mk = dd.DecodeFloat(false)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		mk = dd.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
+			}
+			continue
 		}
 		mv = dd.DecodeBool()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintIntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint]interface{})
-		v, changed := fastpathTV.DecMapUintIntfV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintIntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]interface{})
+		v, changed := fastpathTV.DecMapUintIntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint]interface{})
-		fastpathTV.DecMapUintIntfV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintIntfV(rv2i(rv).(map[uint]interface{}), false, d)
 	}
 }
-func (f fastpathT) DecMapUintIntfX(vp *map[uint]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintIntfV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintIntfX(vp *map[uint]interface{}, d *Decoder) {
+	v, changed := f.DecMapUintIntfV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintIntfV(v map[uint]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintIntfV(v map[uint]interface{}, canChange bool,
 	d *Decoder) (_ map[uint]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -23854,22 +21628,29 @@ func (_ fastpathT) DecMapUintIntfV(v map[uint]interface{}, checkNil bool, canCha
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk uint
 	var mv interface{}
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = nil
+			}
+			continue
 		}
 		if mapGet {
 			mv = v[mk]
@@ -23881,41 +21662,30 @@ func (_ fastpathT) DecMapUintIntfV(v map[uint]interface{}, checkNil bool, canCha
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintStringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint]string)
-		v, changed := fastpathTV.DecMapUintStringV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintStringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]string)
+		v, changed := fastpathTV.DecMapUintStringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint]string)
-		fastpathTV.DecMapUintStringV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintStringV(rv2i(rv).(map[uint]string), false, d)
 	}
 }
-func (f fastpathT) DecMapUintStringX(vp *map[uint]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintStringV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintStringX(vp *map[uint]string, d *Decoder) {
+	v, changed := f.DecMapUintStringV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintStringV(v map[uint]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintStringV(v map[uint]string, canChange bool,
 	d *Decoder) (_ map[uint]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -23923,63 +21693,58 @@ func (_ fastpathT) DecMapUintStringV(v map[uint]string, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint
 	var mv string
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
+			}
+			continue
 		}
 		mv = dd.DecodeString()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintUintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint]uint)
-		v, changed := fastpathTV.DecMapUintUintV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintUintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]uint)
+		v, changed := fastpathTV.DecMapUintUintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint]uint)
-		fastpathTV.DecMapUintUintV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintUintV(rv2i(rv).(map[uint]uint), false, d)
 	}
 }
-func (f fastpathT) DecMapUintUintX(vp *map[uint]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintUintV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintUintX(vp *map[uint]uint, d *Decoder) {
+	v, changed := f.DecMapUintUintV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintUintV(v map[uint]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintUintV(v map[uint]uint, canChange bool,
 	d *Decoder) (_ map[uint]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -23987,63 +21752,58 @@ func (_ fastpathT) DecMapUintUintV(v map[uint]uint, checkNil bool, canChange boo
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint
 	var mv uint
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintUint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint]uint8)
-		v, changed := fastpathTV.DecMapUintUint8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintUint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]uint8)
+		v, changed := fastpathTV.DecMapUintUint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint]uint8)
-		fastpathTV.DecMapUintUint8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintUint8V(rv2i(rv).(map[uint]uint8), false, d)
 	}
 }
-func (f fastpathT) DecMapUintUint8X(vp *map[uint]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintUint8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintUint8X(vp *map[uint]uint8, d *Decoder) {
+	v, changed := f.DecMapUintUint8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintUint8V(v map[uint]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintUint8V(v map[uint]uint8, canChange bool,
 	d *Decoder) (_ map[uint]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -24051,63 +21811,58 @@ func (_ fastpathT) DecMapUintUint8V(v map[uint]uint8, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint
 	var mv uint8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint8(dd.DecodeUint(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintUint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint]uint16)
-		v, changed := fastpathTV.DecMapUintUint16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintUint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]uint16)
+		v, changed := fastpathTV.DecMapUintUint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint]uint16)
-		fastpathTV.DecMapUintUint16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintUint16V(rv2i(rv).(map[uint]uint16), false, d)
 	}
 }
-func (f fastpathT) DecMapUintUint16X(vp *map[uint]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintUint16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintUint16X(vp *map[uint]uint16, d *Decoder) {
+	v, changed := f.DecMapUintUint16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintUint16V(v map[uint]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintUint16V(v map[uint]uint16, canChange bool,
 	d *Decoder) (_ map[uint]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -24115,63 +21870,58 @@ func (_ fastpathT) DecMapUintUint16V(v map[uint]uint16, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint
 	var mv uint16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint16(dd.DecodeUint(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintUint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint]uint32)
-		v, changed := fastpathTV.DecMapUintUint32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintUint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]uint32)
+		v, changed := fastpathTV.DecMapUintUint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint]uint32)
-		fastpathTV.DecMapUintUint32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintUint32V(rv2i(rv).(map[uint]uint32), false, d)
 	}
 }
-func (f fastpathT) DecMapUintUint32X(vp *map[uint]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintUint32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintUint32X(vp *map[uint]uint32, d *Decoder) {
+	v, changed := f.DecMapUintUint32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintUint32V(v map[uint]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintUint32V(v map[uint]uint32, canChange bool,
 	d *Decoder) (_ map[uint]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -24179,63 +21929,58 @@ func (_ fastpathT) DecMapUintUint32V(v map[uint]uint32, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint
 	var mv uint32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint32(dd.DecodeUint(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintUint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint]uint64)
-		v, changed := fastpathTV.DecMapUintUint64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintUint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]uint64)
+		v, changed := fastpathTV.DecMapUintUint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint]uint64)
-		fastpathTV.DecMapUintUint64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintUint64V(rv2i(rv).(map[uint]uint64), false, d)
 	}
 }
-func (f fastpathT) DecMapUintUint64X(vp *map[uint]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintUint64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintUint64X(vp *map[uint]uint64, d *Decoder) {
+	v, changed := f.DecMapUintUint64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintUint64V(v map[uint]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintUint64V(v map[uint]uint64, canChange bool,
 	d *Decoder) (_ map[uint]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -24243,63 +21988,58 @@ func (_ fastpathT) DecMapUintUint64V(v map[uint]uint64, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint
 	var mv uint64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeUint(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintUintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint]uintptr)
-		v, changed := fastpathTV.DecMapUintUintptrV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]uintptr)
+		v, changed := fastpathTV.DecMapUintUintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint]uintptr)
-		fastpathTV.DecMapUintUintptrV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintUintptrV(rv2i(rv).(map[uint]uintptr), false, d)
 	}
 }
-func (f fastpathT) DecMapUintUintptrX(vp *map[uint]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintUintptrV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintUintptrX(vp *map[uint]uintptr, d *Decoder) {
+	v, changed := f.DecMapUintUintptrV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintUintptrV(v map[uint]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintUintptrV(v map[uint]uintptr, canChange bool,
 	d *Decoder) (_ map[uint]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -24307,63 +22047,58 @@ func (_ fastpathT) DecMapUintUintptrV(v map[uint]uintptr, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint
 	var mv uintptr
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uintptr(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintIntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint]int)
-		v, changed := fastpathTV.DecMapUintIntV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintIntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]int)
+		v, changed := fastpathTV.DecMapUintIntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint]int)
-		fastpathTV.DecMapUintIntV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintIntV(rv2i(rv).(map[uint]int), false, d)
 	}
 }
-func (f fastpathT) DecMapUintIntX(vp *map[uint]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintIntV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintIntX(vp *map[uint]int, d *Decoder) {
+	v, changed := f.DecMapUintIntV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintIntV(v map[uint]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintIntV(v map[uint]int, canChange bool,
 	d *Decoder) (_ map[uint]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -24371,63 +22106,58 @@ func (_ fastpathT) DecMapUintIntV(v map[uint]int, checkNil bool, canChange bool,
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint
 	var mv int
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int(dd.DecodeInt(intBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintInt8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint]int8)
-		v, changed := fastpathTV.DecMapUintInt8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintInt8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]int8)
+		v, changed := fastpathTV.DecMapUintInt8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint]int8)
-		fastpathTV.DecMapUintInt8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintInt8V(rv2i(rv).(map[uint]int8), false, d)
 	}
 }
-func (f fastpathT) DecMapUintInt8X(vp *map[uint]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintInt8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintInt8X(vp *map[uint]int8, d *Decoder) {
+	v, changed := f.DecMapUintInt8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintInt8V(v map[uint]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintInt8V(v map[uint]int8, canChange bool,
 	d *Decoder) (_ map[uint]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -24435,63 +22165,58 @@ func (_ fastpathT) DecMapUintInt8V(v map[uint]int8, checkNil bool, canChange boo
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint
 	var mv int8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int8(dd.DecodeInt(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintInt16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint]int16)
-		v, changed := fastpathTV.DecMapUintInt16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintInt16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]int16)
+		v, changed := fastpathTV.DecMapUintInt16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint]int16)
-		fastpathTV.DecMapUintInt16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintInt16V(rv2i(rv).(map[uint]int16), false, d)
 	}
 }
-func (f fastpathT) DecMapUintInt16X(vp *map[uint]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintInt16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintInt16X(vp *map[uint]int16, d *Decoder) {
+	v, changed := f.DecMapUintInt16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintInt16V(v map[uint]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintInt16V(v map[uint]int16, canChange bool,
 	d *Decoder) (_ map[uint]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -24499,63 +22224,58 @@ func (_ fastpathT) DecMapUintInt16V(v map[uint]int16, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint
 	var mv int16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int16(dd.DecodeInt(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintInt32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint]int32)
-		v, changed := fastpathTV.DecMapUintInt32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintInt32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]int32)
+		v, changed := fastpathTV.DecMapUintInt32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint]int32)
-		fastpathTV.DecMapUintInt32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintInt32V(rv2i(rv).(map[uint]int32), false, d)
 	}
 }
-func (f fastpathT) DecMapUintInt32X(vp *map[uint]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintInt32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintInt32X(vp *map[uint]int32, d *Decoder) {
+	v, changed := f.DecMapUintInt32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintInt32V(v map[uint]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintInt32V(v map[uint]int32, canChange bool,
 	d *Decoder) (_ map[uint]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -24563,63 +22283,58 @@ func (_ fastpathT) DecMapUintInt32V(v map[uint]int32, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint
 	var mv int32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int32(dd.DecodeInt(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintInt64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint]int64)
-		v, changed := fastpathTV.DecMapUintInt64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintInt64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]int64)
+		v, changed := fastpathTV.DecMapUintInt64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint]int64)
-		fastpathTV.DecMapUintInt64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintInt64V(rv2i(rv).(map[uint]int64), false, d)
 	}
 }
-func (f fastpathT) DecMapUintInt64X(vp *map[uint]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintInt64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintInt64X(vp *map[uint]int64, d *Decoder) {
+	v, changed := f.DecMapUintInt64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintInt64V(v map[uint]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintInt64V(v map[uint]int64, canChange bool,
 	d *Decoder) (_ map[uint]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -24627,63 +22342,58 @@ func (_ fastpathT) DecMapUintInt64V(v map[uint]int64, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint
 	var mv int64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeInt(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintFloat32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint]float32)
-		v, changed := fastpathTV.DecMapUintFloat32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintFloat32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]float32)
+		v, changed := fastpathTV.DecMapUintFloat32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint]float32)
-		fastpathTV.DecMapUintFloat32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintFloat32V(rv2i(rv).(map[uint]float32), false, d)
 	}
 }
-func (f fastpathT) DecMapUintFloat32X(vp *map[uint]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintFloat32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintFloat32X(vp *map[uint]float32, d *Decoder) {
+	v, changed := f.DecMapUintFloat32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintFloat32V(v map[uint]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintFloat32V(v map[uint]float32, canChange bool,
 	d *Decoder) (_ map[uint]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -24691,63 +22401,58 @@ func (_ fastpathT) DecMapUintFloat32V(v map[uint]float32, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint
 	var mv float32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = float32(dd.DecodeFloat(true))
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = float32(chkFloat32(dd.DecodeFloat64()))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintFloat64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint]float64)
-		v, changed := fastpathTV.DecMapUintFloat64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintFloat64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]float64)
+		v, changed := fastpathTV.DecMapUintFloat64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint]float64)
-		fastpathTV.DecMapUintFloat64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintFloat64V(rv2i(rv).(map[uint]float64), false, d)
 	}
 }
-func (f fastpathT) DecMapUintFloat64X(vp *map[uint]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintFloat64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintFloat64X(vp *map[uint]float64, d *Decoder) {
+	v, changed := f.DecMapUintFloat64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintFloat64V(v map[uint]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintFloat64V(v map[uint]float64, canChange bool,
 	d *Decoder) (_ map[uint]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -24755,63 +22460,58 @@ func (_ fastpathT) DecMapUintFloat64V(v map[uint]float64, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint
 	var mv float64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = dd.DecodeFloat(false)
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintBoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint]bool)
-		v, changed := fastpathTV.DecMapUintBoolV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintBoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]bool)
+		v, changed := fastpathTV.DecMapUintBoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint]bool)
-		fastpathTV.DecMapUintBoolV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintBoolV(rv2i(rv).(map[uint]bool), false, d)
 	}
 }
-func (f fastpathT) DecMapUintBoolX(vp *map[uint]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintBoolV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintBoolX(vp *map[uint]bool, d *Decoder) {
+	v, changed := f.DecMapUintBoolV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintBoolV(v map[uint]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintBoolV(v map[uint]bool, canChange bool,
 	d *Decoder) (_ map[uint]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -24819,63 +22519,58 @@ func (_ fastpathT) DecMapUintBoolV(v map[uint]bool, checkNil bool, canChange boo
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint
 	var mv bool
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
+			}
+			continue
 		}
 		mv = dd.DecodeBool()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8IntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint8]interface{})
-		v, changed := fastpathTV.DecMapUint8IntfV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint8IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]interface{})
+		v, changed := fastpathTV.DecMapUint8IntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint8]interface{})
-		fastpathTV.DecMapUint8IntfV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint8IntfV(rv2i(rv).(map[uint8]interface{}), false, d)
 	}
 }
-func (f fastpathT) DecMapUint8IntfX(vp *map[uint8]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8IntfV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint8IntfX(vp *map[uint8]interface{}, d *Decoder) {
+	v, changed := f.DecMapUint8IntfV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8IntfV(v map[uint8]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8IntfV(v map[uint8]interface{}, canChange bool,
 	d *Decoder) (_ map[uint8]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
@@ -24883,22 +22578,29 @@ func (_ fastpathT) DecMapUint8IntfV(v map[uint8]interface{}, checkNil bool, canC
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk uint8
 	var mv interface{}
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint8(dd.DecodeUint(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = nil
+			}
+			continue
 		}
 		if mapGet {
 			mv = v[mk]
@@ -24910,41 +22612,30 @@ func (_ fastpathT) DecMapUint8IntfV(v map[uint8]interface{}, checkNil bool, canC
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8StringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint8]string)
-		v, changed := fastpathTV.DecMapUint8StringV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint8StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]string)
+		v, changed := fastpathTV.DecMapUint8StringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint8]string)
-		fastpathTV.DecMapUint8StringV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint8StringV(rv2i(rv).(map[uint8]string), false, d)
 	}
 }
-func (f fastpathT) DecMapUint8StringX(vp *map[uint8]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8StringV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint8StringX(vp *map[uint8]string, d *Decoder) {
+	v, changed := f.DecMapUint8StringV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8StringV(v map[uint8]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8StringV(v map[uint8]string, canChange bool,
 	d *Decoder) (_ map[uint8]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
@@ -24952,63 +22643,58 @@ func (_ fastpathT) DecMapUint8StringV(v map[uint8]string, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint8
 	var mv string
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint8(dd.DecodeUint(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
+			}
+			continue
 		}
 		mv = dd.DecodeString()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8UintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint8]uint)
-		v, changed := fastpathTV.DecMapUint8UintV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint8UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]uint)
+		v, changed := fastpathTV.DecMapUint8UintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint8]uint)
-		fastpathTV.DecMapUint8UintV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint8UintV(rv2i(rv).(map[uint8]uint), false, d)
 	}
 }
-func (f fastpathT) DecMapUint8UintX(vp *map[uint8]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8UintV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint8UintX(vp *map[uint8]uint, d *Decoder) {
+	v, changed := f.DecMapUint8UintV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8UintV(v map[uint8]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8UintV(v map[uint8]uint, canChange bool,
 	d *Decoder) (_ map[uint8]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -25016,63 +22702,58 @@ func (_ fastpathT) DecMapUint8UintV(v map[uint8]uint, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint8
 	var mv uint
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint8(dd.DecodeUint(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8Uint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint8]uint8)
-		v, changed := fastpathTV.DecMapUint8Uint8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint8Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]uint8)
+		v, changed := fastpathTV.DecMapUint8Uint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint8]uint8)
-		fastpathTV.DecMapUint8Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint8Uint8V(rv2i(rv).(map[uint8]uint8), false, d)
 	}
 }
-func (f fastpathT) DecMapUint8Uint8X(vp *map[uint8]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8Uint8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint8Uint8X(vp *map[uint8]uint8, d *Decoder) {
+	v, changed := f.DecMapUint8Uint8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8Uint8V(v map[uint8]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8Uint8V(v map[uint8]uint8, canChange bool,
 	d *Decoder) (_ map[uint8]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
@@ -25080,63 +22761,58 @@ func (_ fastpathT) DecMapUint8Uint8V(v map[uint8]uint8, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint8
 	var mv uint8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint8(dd.DecodeUint(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint8(dd.DecodeUint(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8Uint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint8]uint16)
-		v, changed := fastpathTV.DecMapUint8Uint16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint8Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]uint16)
+		v, changed := fastpathTV.DecMapUint8Uint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint8]uint16)
-		fastpathTV.DecMapUint8Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint8Uint16V(rv2i(rv).(map[uint8]uint16), false, d)
 	}
 }
-func (f fastpathT) DecMapUint8Uint16X(vp *map[uint8]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8Uint16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint8Uint16X(vp *map[uint8]uint16, d *Decoder) {
+	v, changed := f.DecMapUint8Uint16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8Uint16V(v map[uint8]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8Uint16V(v map[uint8]uint16, canChange bool,
 	d *Decoder) (_ map[uint8]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
@@ -25144,63 +22820,58 @@ func (_ fastpathT) DecMapUint8Uint16V(v map[uint8]uint16, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint8
 	var mv uint16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint8(dd.DecodeUint(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint16(dd.DecodeUint(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8Uint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint8]uint32)
-		v, changed := fastpathTV.DecMapUint8Uint32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint8Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]uint32)
+		v, changed := fastpathTV.DecMapUint8Uint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint8]uint32)
-		fastpathTV.DecMapUint8Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint8Uint32V(rv2i(rv).(map[uint8]uint32), false, d)
 	}
 }
-func (f fastpathT) DecMapUint8Uint32X(vp *map[uint8]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8Uint32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint8Uint32X(vp *map[uint8]uint32, d *Decoder) {
+	v, changed := f.DecMapUint8Uint32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8Uint32V(v map[uint8]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8Uint32V(v map[uint8]uint32, canChange bool,
 	d *Decoder) (_ map[uint8]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
@@ -25208,63 +22879,58 @@ func (_ fastpathT) DecMapUint8Uint32V(v map[uint8]uint32, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint8
 	var mv uint32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint8(dd.DecodeUint(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint32(dd.DecodeUint(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8Uint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint8]uint64)
-		v, changed := fastpathTV.DecMapUint8Uint64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint8Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]uint64)
+		v, changed := fastpathTV.DecMapUint8Uint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint8]uint64)
-		fastpathTV.DecMapUint8Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint8Uint64V(rv2i(rv).(map[uint8]uint64), false, d)
 	}
 }
-func (f fastpathT) DecMapUint8Uint64X(vp *map[uint8]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8Uint64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint8Uint64X(vp *map[uint8]uint64, d *Decoder) {
+	v, changed := f.DecMapUint8Uint64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8Uint64V(v map[uint8]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8Uint64V(v map[uint8]uint64, canChange bool,
 	d *Decoder) (_ map[uint8]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -25272,63 +22938,58 @@ func (_ fastpathT) DecMapUint8Uint64V(v map[uint8]uint64, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint8
 	var mv uint64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint8(dd.DecodeUint(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeUint(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8UintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint8]uintptr)
-		v, changed := fastpathTV.DecMapUint8UintptrV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint8UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]uintptr)
+		v, changed := fastpathTV.DecMapUint8UintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint8]uintptr)
-		fastpathTV.DecMapUint8UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint8UintptrV(rv2i(rv).(map[uint8]uintptr), false, d)
 	}
 }
-func (f fastpathT) DecMapUint8UintptrX(vp *map[uint8]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8UintptrV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint8UintptrX(vp *map[uint8]uintptr, d *Decoder) {
+	v, changed := f.DecMapUint8UintptrV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8UintptrV(v map[uint8]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8UintptrV(v map[uint8]uintptr, canChange bool,
 	d *Decoder) (_ map[uint8]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -25336,63 +22997,58 @@ func (_ fastpathT) DecMapUint8UintptrV(v map[uint8]uintptr, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint8
 	var mv uintptr
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint8(dd.DecodeUint(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uintptr(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8IntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint8]int)
-		v, changed := fastpathTV.DecMapUint8IntV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint8IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]int)
+		v, changed := fastpathTV.DecMapUint8IntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint8]int)
-		fastpathTV.DecMapUint8IntV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint8IntV(rv2i(rv).(map[uint8]int), false, d)
 	}
 }
-func (f fastpathT) DecMapUint8IntX(vp *map[uint8]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8IntV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint8IntX(vp *map[uint8]int, d *Decoder) {
+	v, changed := f.DecMapUint8IntV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8IntV(v map[uint8]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8IntV(v map[uint8]int, canChange bool,
 	d *Decoder) (_ map[uint8]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -25400,63 +23056,58 @@ func (_ fastpathT) DecMapUint8IntV(v map[uint8]int, checkNil bool, canChange boo
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint8
 	var mv int
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint8(dd.DecodeUint(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int(dd.DecodeInt(intBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8Int8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint8]int8)
-		v, changed := fastpathTV.DecMapUint8Int8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint8Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]int8)
+		v, changed := fastpathTV.DecMapUint8Int8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint8]int8)
-		fastpathTV.DecMapUint8Int8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint8Int8V(rv2i(rv).(map[uint8]int8), false, d)
 	}
 }
-func (f fastpathT) DecMapUint8Int8X(vp *map[uint8]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8Int8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint8Int8X(vp *map[uint8]int8, d *Decoder) {
+	v, changed := f.DecMapUint8Int8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8Int8V(v map[uint8]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8Int8V(v map[uint8]int8, canChange bool,
 	d *Decoder) (_ map[uint8]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
@@ -25464,63 +23115,58 @@ func (_ fastpathT) DecMapUint8Int8V(v map[uint8]int8, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint8
 	var mv int8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint8(dd.DecodeUint(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int8(dd.DecodeInt(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8Int16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint8]int16)
-		v, changed := fastpathTV.DecMapUint8Int16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint8Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]int16)
+		v, changed := fastpathTV.DecMapUint8Int16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint8]int16)
-		fastpathTV.DecMapUint8Int16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint8Int16V(rv2i(rv).(map[uint8]int16), false, d)
 	}
 }
-func (f fastpathT) DecMapUint8Int16X(vp *map[uint8]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8Int16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint8Int16X(vp *map[uint8]int16, d *Decoder) {
+	v, changed := f.DecMapUint8Int16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8Int16V(v map[uint8]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8Int16V(v map[uint8]int16, canChange bool,
 	d *Decoder) (_ map[uint8]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
@@ -25528,63 +23174,58 @@ func (_ fastpathT) DecMapUint8Int16V(v map[uint8]int16, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint8
 	var mv int16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint8(dd.DecodeUint(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int16(dd.DecodeInt(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8Int32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint8]int32)
-		v, changed := fastpathTV.DecMapUint8Int32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint8Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]int32)
+		v, changed := fastpathTV.DecMapUint8Int32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint8]int32)
-		fastpathTV.DecMapUint8Int32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint8Int32V(rv2i(rv).(map[uint8]int32), false, d)
 	}
 }
-func (f fastpathT) DecMapUint8Int32X(vp *map[uint8]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8Int32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint8Int32X(vp *map[uint8]int32, d *Decoder) {
+	v, changed := f.DecMapUint8Int32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8Int32V(v map[uint8]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8Int32V(v map[uint8]int32, canChange bool,
 	d *Decoder) (_ map[uint8]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
@@ -25592,63 +23233,58 @@ func (_ fastpathT) DecMapUint8Int32V(v map[uint8]int32, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint8
 	var mv int32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint8(dd.DecodeUint(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int32(dd.DecodeInt(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8Int64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint8]int64)
-		v, changed := fastpathTV.DecMapUint8Int64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint8Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]int64)
+		v, changed := fastpathTV.DecMapUint8Int64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint8]int64)
-		fastpathTV.DecMapUint8Int64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint8Int64V(rv2i(rv).(map[uint8]int64), false, d)
 	}
 }
-func (f fastpathT) DecMapUint8Int64X(vp *map[uint8]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8Int64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint8Int64X(vp *map[uint8]int64, d *Decoder) {
+	v, changed := f.DecMapUint8Int64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8Int64V(v map[uint8]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8Int64V(v map[uint8]int64, canChange bool,
 	d *Decoder) (_ map[uint8]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -25656,63 +23292,58 @@ func (_ fastpathT) DecMapUint8Int64V(v map[uint8]int64, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint8
 	var mv int64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint8(dd.DecodeUint(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeInt(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8Float32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint8]float32)
-		v, changed := fastpathTV.DecMapUint8Float32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint8Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]float32)
+		v, changed := fastpathTV.DecMapUint8Float32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint8]float32)
-		fastpathTV.DecMapUint8Float32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint8Float32V(rv2i(rv).(map[uint8]float32), false, d)
 	}
 }
-func (f fastpathT) DecMapUint8Float32X(vp *map[uint8]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8Float32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint8Float32X(vp *map[uint8]float32, d *Decoder) {
+	v, changed := f.DecMapUint8Float32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8Float32V(v map[uint8]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8Float32V(v map[uint8]float32, canChange bool,
 	d *Decoder) (_ map[uint8]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
@@ -25720,63 +23351,58 @@ func (_ fastpathT) DecMapUint8Float32V(v map[uint8]float32, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint8
 	var mv float32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint8(dd.DecodeUint(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = float32(dd.DecodeFloat(true))
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = float32(chkFloat32(dd.DecodeFloat64()))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8Float64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint8]float64)
-		v, changed := fastpathTV.DecMapUint8Float64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint8Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]float64)
+		v, changed := fastpathTV.DecMapUint8Float64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint8]float64)
-		fastpathTV.DecMapUint8Float64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint8Float64V(rv2i(rv).(map[uint8]float64), false, d)
 	}
 }
-func (f fastpathT) DecMapUint8Float64X(vp *map[uint8]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8Float64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint8Float64X(vp *map[uint8]float64, d *Decoder) {
+	v, changed := f.DecMapUint8Float64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8Float64V(v map[uint8]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8Float64V(v map[uint8]float64, canChange bool,
 	d *Decoder) (_ map[uint8]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -25784,63 +23410,58 @@ func (_ fastpathT) DecMapUint8Float64V(v map[uint8]float64, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint8
 	var mv float64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint8(dd.DecodeUint(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = dd.DecodeFloat(false)
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint8BoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint8]bool)
-		v, changed := fastpathTV.DecMapUint8BoolV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint8BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]bool)
+		v, changed := fastpathTV.DecMapUint8BoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint8]bool)
-		fastpathTV.DecMapUint8BoolV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint8BoolV(rv2i(rv).(map[uint8]bool), false, d)
 	}
 }
-func (f fastpathT) DecMapUint8BoolX(vp *map[uint8]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint8BoolV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint8BoolX(vp *map[uint8]bool, d *Decoder) {
+	v, changed := f.DecMapUint8BoolV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint8BoolV(v map[uint8]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint8BoolV(v map[uint8]bool, canChange bool,
 	d *Decoder) (_ map[uint8]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
@@ -25848,63 +23469,58 @@ func (_ fastpathT) DecMapUint8BoolV(v map[uint8]bool, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint8
 	var mv bool
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint8(dd.DecodeUint(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
+			}
+			continue
 		}
 		mv = dd.DecodeBool()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16IntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint16]interface{})
-		v, changed := fastpathTV.DecMapUint16IntfV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint16IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]interface{})
+		v, changed := fastpathTV.DecMapUint16IntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint16]interface{})
-		fastpathTV.DecMapUint16IntfV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint16IntfV(rv2i(rv).(map[uint16]interface{}), false, d)
 	}
 }
-func (f fastpathT) DecMapUint16IntfX(vp *map[uint16]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16IntfV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint16IntfX(vp *map[uint16]interface{}, d *Decoder) {
+	v, changed := f.DecMapUint16IntfV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16IntfV(v map[uint16]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16IntfV(v map[uint16]interface{}, canChange bool,
 	d *Decoder) (_ map[uint16]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
@@ -25912,22 +23528,29 @@ func (_ fastpathT) DecMapUint16IntfV(v map[uint16]interface{}, checkNil bool, ca
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk uint16
 	var mv interface{}
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint16(dd.DecodeUint(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = nil
+			}
+			continue
 		}
 		if mapGet {
 			mv = v[mk]
@@ -25939,41 +23562,30 @@ func (_ fastpathT) DecMapUint16IntfV(v map[uint16]interface{}, checkNil bool, ca
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16StringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint16]string)
-		v, changed := fastpathTV.DecMapUint16StringV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint16StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]string)
+		v, changed := fastpathTV.DecMapUint16StringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint16]string)
-		fastpathTV.DecMapUint16StringV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint16StringV(rv2i(rv).(map[uint16]string), false, d)
 	}
 }
-func (f fastpathT) DecMapUint16StringX(vp *map[uint16]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16StringV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint16StringX(vp *map[uint16]string, d *Decoder) {
+	v, changed := f.DecMapUint16StringV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16StringV(v map[uint16]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16StringV(v map[uint16]string, canChange bool,
 	d *Decoder) (_ map[uint16]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
@@ -25981,63 +23593,58 @@ func (_ fastpathT) DecMapUint16StringV(v map[uint16]string, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint16
 	var mv string
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint16(dd.DecodeUint(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
+			}
+			continue
 		}
 		mv = dd.DecodeString()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16UintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint16]uint)
-		v, changed := fastpathTV.DecMapUint16UintV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint16UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]uint)
+		v, changed := fastpathTV.DecMapUint16UintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint16]uint)
-		fastpathTV.DecMapUint16UintV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint16UintV(rv2i(rv).(map[uint16]uint), false, d)
 	}
 }
-func (f fastpathT) DecMapUint16UintX(vp *map[uint16]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16UintV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint16UintX(vp *map[uint16]uint, d *Decoder) {
+	v, changed := f.DecMapUint16UintV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16UintV(v map[uint16]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16UintV(v map[uint16]uint, canChange bool,
 	d *Decoder) (_ map[uint16]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -26045,63 +23652,58 @@ func (_ fastpathT) DecMapUint16UintV(v map[uint16]uint, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint16
 	var mv uint
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint16(dd.DecodeUint(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16Uint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint16]uint8)
-		v, changed := fastpathTV.DecMapUint16Uint8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint16Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]uint8)
+		v, changed := fastpathTV.DecMapUint16Uint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint16]uint8)
-		fastpathTV.DecMapUint16Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint16Uint8V(rv2i(rv).(map[uint16]uint8), false, d)
 	}
 }
-func (f fastpathT) DecMapUint16Uint8X(vp *map[uint16]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16Uint8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint16Uint8X(vp *map[uint16]uint8, d *Decoder) {
+	v, changed := f.DecMapUint16Uint8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16Uint8V(v map[uint16]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16Uint8V(v map[uint16]uint8, canChange bool,
 	d *Decoder) (_ map[uint16]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
@@ -26109,63 +23711,58 @@ func (_ fastpathT) DecMapUint16Uint8V(v map[uint16]uint8, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint16
 	var mv uint8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint16(dd.DecodeUint(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint8(dd.DecodeUint(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16Uint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint16]uint16)
-		v, changed := fastpathTV.DecMapUint16Uint16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint16Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]uint16)
+		v, changed := fastpathTV.DecMapUint16Uint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint16]uint16)
-		fastpathTV.DecMapUint16Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint16Uint16V(rv2i(rv).(map[uint16]uint16), false, d)
 	}
 }
-func (f fastpathT) DecMapUint16Uint16X(vp *map[uint16]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16Uint16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint16Uint16X(vp *map[uint16]uint16, d *Decoder) {
+	v, changed := f.DecMapUint16Uint16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16Uint16V(v map[uint16]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16Uint16V(v map[uint16]uint16, canChange bool,
 	d *Decoder) (_ map[uint16]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 4)
@@ -26173,63 +23770,58 @@ func (_ fastpathT) DecMapUint16Uint16V(v map[uint16]uint16, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint16
 	var mv uint16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint16(dd.DecodeUint(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint16(dd.DecodeUint(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16Uint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint16]uint32)
-		v, changed := fastpathTV.DecMapUint16Uint32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint16Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]uint32)
+		v, changed := fastpathTV.DecMapUint16Uint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint16]uint32)
-		fastpathTV.DecMapUint16Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint16Uint32V(rv2i(rv).(map[uint16]uint32), false, d)
 	}
 }
-func (f fastpathT) DecMapUint16Uint32X(vp *map[uint16]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16Uint32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint16Uint32X(vp *map[uint16]uint32, d *Decoder) {
+	v, changed := f.DecMapUint16Uint32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16Uint32V(v map[uint16]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16Uint32V(v map[uint16]uint32, canChange bool,
 	d *Decoder) (_ map[uint16]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
@@ -26237,63 +23829,58 @@ func (_ fastpathT) DecMapUint16Uint32V(v map[uint16]uint32, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint16
 	var mv uint32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint16(dd.DecodeUint(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint32(dd.DecodeUint(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16Uint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint16]uint64)
-		v, changed := fastpathTV.DecMapUint16Uint64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint16Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]uint64)
+		v, changed := fastpathTV.DecMapUint16Uint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint16]uint64)
-		fastpathTV.DecMapUint16Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint16Uint64V(rv2i(rv).(map[uint16]uint64), false, d)
 	}
 }
-func (f fastpathT) DecMapUint16Uint64X(vp *map[uint16]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16Uint64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint16Uint64X(vp *map[uint16]uint64, d *Decoder) {
+	v, changed := f.DecMapUint16Uint64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16Uint64V(v map[uint16]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16Uint64V(v map[uint16]uint64, canChange bool,
 	d *Decoder) (_ map[uint16]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -26301,63 +23888,58 @@ func (_ fastpathT) DecMapUint16Uint64V(v map[uint16]uint64, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint16
 	var mv uint64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint16(dd.DecodeUint(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeUint(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16UintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint16]uintptr)
-		v, changed := fastpathTV.DecMapUint16UintptrV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint16UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]uintptr)
+		v, changed := fastpathTV.DecMapUint16UintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint16]uintptr)
-		fastpathTV.DecMapUint16UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint16UintptrV(rv2i(rv).(map[uint16]uintptr), false, d)
 	}
 }
-func (f fastpathT) DecMapUint16UintptrX(vp *map[uint16]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16UintptrV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint16UintptrX(vp *map[uint16]uintptr, d *Decoder) {
+	v, changed := f.DecMapUint16UintptrV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16UintptrV(v map[uint16]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16UintptrV(v map[uint16]uintptr, canChange bool,
 	d *Decoder) (_ map[uint16]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -26365,63 +23947,58 @@ func (_ fastpathT) DecMapUint16UintptrV(v map[uint16]uintptr, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint16
 	var mv uintptr
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint16(dd.DecodeUint(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uintptr(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16IntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint16]int)
-		v, changed := fastpathTV.DecMapUint16IntV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint16IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]int)
+		v, changed := fastpathTV.DecMapUint16IntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint16]int)
-		fastpathTV.DecMapUint16IntV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint16IntV(rv2i(rv).(map[uint16]int), false, d)
 	}
 }
-func (f fastpathT) DecMapUint16IntX(vp *map[uint16]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16IntV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint16IntX(vp *map[uint16]int, d *Decoder) {
+	v, changed := f.DecMapUint16IntV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16IntV(v map[uint16]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16IntV(v map[uint16]int, canChange bool,
 	d *Decoder) (_ map[uint16]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -26429,63 +24006,58 @@ func (_ fastpathT) DecMapUint16IntV(v map[uint16]int, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint16
 	var mv int
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint16(dd.DecodeUint(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int(dd.DecodeInt(intBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16Int8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint16]int8)
-		v, changed := fastpathTV.DecMapUint16Int8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint16Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]int8)
+		v, changed := fastpathTV.DecMapUint16Int8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint16]int8)
-		fastpathTV.DecMapUint16Int8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint16Int8V(rv2i(rv).(map[uint16]int8), false, d)
 	}
 }
-func (f fastpathT) DecMapUint16Int8X(vp *map[uint16]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16Int8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint16Int8X(vp *map[uint16]int8, d *Decoder) {
+	v, changed := f.DecMapUint16Int8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16Int8V(v map[uint16]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16Int8V(v map[uint16]int8, canChange bool,
 	d *Decoder) (_ map[uint16]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
@@ -26493,63 +24065,58 @@ func (_ fastpathT) DecMapUint16Int8V(v map[uint16]int8, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint16
 	var mv int8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint16(dd.DecodeUint(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int8(dd.DecodeInt(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16Int16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint16]int16)
-		v, changed := fastpathTV.DecMapUint16Int16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint16Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]int16)
+		v, changed := fastpathTV.DecMapUint16Int16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint16]int16)
-		fastpathTV.DecMapUint16Int16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint16Int16V(rv2i(rv).(map[uint16]int16), false, d)
 	}
 }
-func (f fastpathT) DecMapUint16Int16X(vp *map[uint16]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16Int16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint16Int16X(vp *map[uint16]int16, d *Decoder) {
+	v, changed := f.DecMapUint16Int16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16Int16V(v map[uint16]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16Int16V(v map[uint16]int16, canChange bool,
 	d *Decoder) (_ map[uint16]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 4)
@@ -26557,63 +24124,58 @@ func (_ fastpathT) DecMapUint16Int16V(v map[uint16]int16, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint16
 	var mv int16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint16(dd.DecodeUint(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int16(dd.DecodeInt(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16Int32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint16]int32)
-		v, changed := fastpathTV.DecMapUint16Int32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint16Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]int32)
+		v, changed := fastpathTV.DecMapUint16Int32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint16]int32)
-		fastpathTV.DecMapUint16Int32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint16Int32V(rv2i(rv).(map[uint16]int32), false, d)
 	}
 }
-func (f fastpathT) DecMapUint16Int32X(vp *map[uint16]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16Int32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint16Int32X(vp *map[uint16]int32, d *Decoder) {
+	v, changed := f.DecMapUint16Int32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16Int32V(v map[uint16]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16Int32V(v map[uint16]int32, canChange bool,
 	d *Decoder) (_ map[uint16]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
@@ -26621,63 +24183,58 @@ func (_ fastpathT) DecMapUint16Int32V(v map[uint16]int32, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint16
 	var mv int32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint16(dd.DecodeUint(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int32(dd.DecodeInt(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16Int64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint16]int64)
-		v, changed := fastpathTV.DecMapUint16Int64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint16Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]int64)
+		v, changed := fastpathTV.DecMapUint16Int64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint16]int64)
-		fastpathTV.DecMapUint16Int64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint16Int64V(rv2i(rv).(map[uint16]int64), false, d)
 	}
 }
-func (f fastpathT) DecMapUint16Int64X(vp *map[uint16]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16Int64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint16Int64X(vp *map[uint16]int64, d *Decoder) {
+	v, changed := f.DecMapUint16Int64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16Int64V(v map[uint16]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16Int64V(v map[uint16]int64, canChange bool,
 	d *Decoder) (_ map[uint16]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -26685,63 +24242,58 @@ func (_ fastpathT) DecMapUint16Int64V(v map[uint16]int64, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint16
 	var mv int64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint16(dd.DecodeUint(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeInt(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16Float32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint16]float32)
-		v, changed := fastpathTV.DecMapUint16Float32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint16Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]float32)
+		v, changed := fastpathTV.DecMapUint16Float32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint16]float32)
-		fastpathTV.DecMapUint16Float32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint16Float32V(rv2i(rv).(map[uint16]float32), false, d)
 	}
 }
-func (f fastpathT) DecMapUint16Float32X(vp *map[uint16]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16Float32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint16Float32X(vp *map[uint16]float32, d *Decoder) {
+	v, changed := f.DecMapUint16Float32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16Float32V(v map[uint16]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16Float32V(v map[uint16]float32, canChange bool,
 	d *Decoder) (_ map[uint16]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
@@ -26749,63 +24301,58 @@ func (_ fastpathT) DecMapUint16Float32V(v map[uint16]float32, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint16
 	var mv float32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint16(dd.DecodeUint(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = float32(dd.DecodeFloat(true))
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = float32(chkFloat32(dd.DecodeFloat64()))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16Float64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint16]float64)
-		v, changed := fastpathTV.DecMapUint16Float64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint16Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]float64)
+		v, changed := fastpathTV.DecMapUint16Float64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint16]float64)
-		fastpathTV.DecMapUint16Float64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint16Float64V(rv2i(rv).(map[uint16]float64), false, d)
 	}
 }
-func (f fastpathT) DecMapUint16Float64X(vp *map[uint16]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16Float64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint16Float64X(vp *map[uint16]float64, d *Decoder) {
+	v, changed := f.DecMapUint16Float64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16Float64V(v map[uint16]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16Float64V(v map[uint16]float64, canChange bool,
 	d *Decoder) (_ map[uint16]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -26813,63 +24360,58 @@ func (_ fastpathT) DecMapUint16Float64V(v map[uint16]float64, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint16
 	var mv float64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint16(dd.DecodeUint(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = dd.DecodeFloat(false)
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint16BoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint16]bool)
-		v, changed := fastpathTV.DecMapUint16BoolV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint16BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]bool)
+		v, changed := fastpathTV.DecMapUint16BoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint16]bool)
-		fastpathTV.DecMapUint16BoolV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint16BoolV(rv2i(rv).(map[uint16]bool), false, d)
 	}
 }
-func (f fastpathT) DecMapUint16BoolX(vp *map[uint16]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint16BoolV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint16BoolX(vp *map[uint16]bool, d *Decoder) {
+	v, changed := f.DecMapUint16BoolV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint16BoolV(v map[uint16]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint16BoolV(v map[uint16]bool, canChange bool,
 	d *Decoder) (_ map[uint16]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
@@ -26877,63 +24419,58 @@ func (_ fastpathT) DecMapUint16BoolV(v map[uint16]bool, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint16
 	var mv bool
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint16(dd.DecodeUint(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
+			}
+			continue
 		}
 		mv = dd.DecodeBool()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32IntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint32]interface{})
-		v, changed := fastpathTV.DecMapUint32IntfV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint32IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]interface{})
+		v, changed := fastpathTV.DecMapUint32IntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint32]interface{})
-		fastpathTV.DecMapUint32IntfV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint32IntfV(rv2i(rv).(map[uint32]interface{}), false, d)
 	}
 }
-func (f fastpathT) DecMapUint32IntfX(vp *map[uint32]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32IntfV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint32IntfX(vp *map[uint32]interface{}, d *Decoder) {
+	v, changed := f.DecMapUint32IntfV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32IntfV(v map[uint32]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32IntfV(v map[uint32]interface{}, canChange bool,
 	d *Decoder) (_ map[uint32]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
@@ -26941,22 +24478,29 @@ func (_ fastpathT) DecMapUint32IntfV(v map[uint32]interface{}, checkNil bool, ca
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk uint32
 	var mv interface{}
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint32(dd.DecodeUint(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = nil
+			}
+			continue
 		}
 		if mapGet {
 			mv = v[mk]
@@ -26968,41 +24512,30 @@ func (_ fastpathT) DecMapUint32IntfV(v map[uint32]interface{}, checkNil bool, ca
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32StringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint32]string)
-		v, changed := fastpathTV.DecMapUint32StringV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint32StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]string)
+		v, changed := fastpathTV.DecMapUint32StringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint32]string)
-		fastpathTV.DecMapUint32StringV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint32StringV(rv2i(rv).(map[uint32]string), false, d)
 	}
 }
-func (f fastpathT) DecMapUint32StringX(vp *map[uint32]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32StringV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint32StringX(vp *map[uint32]string, d *Decoder) {
+	v, changed := f.DecMapUint32StringV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32StringV(v map[uint32]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32StringV(v map[uint32]string, canChange bool,
 	d *Decoder) (_ map[uint32]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
@@ -27010,63 +24543,58 @@ func (_ fastpathT) DecMapUint32StringV(v map[uint32]string, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint32
 	var mv string
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint32(dd.DecodeUint(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
+			}
+			continue
 		}
 		mv = dd.DecodeString()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32UintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint32]uint)
-		v, changed := fastpathTV.DecMapUint32UintV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint32UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]uint)
+		v, changed := fastpathTV.DecMapUint32UintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint32]uint)
-		fastpathTV.DecMapUint32UintV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint32UintV(rv2i(rv).(map[uint32]uint), false, d)
 	}
 }
-func (f fastpathT) DecMapUint32UintX(vp *map[uint32]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32UintV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint32UintX(vp *map[uint32]uint, d *Decoder) {
+	v, changed := f.DecMapUint32UintV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32UintV(v map[uint32]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32UintV(v map[uint32]uint, canChange bool,
 	d *Decoder) (_ map[uint32]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -27074,63 +24602,58 @@ func (_ fastpathT) DecMapUint32UintV(v map[uint32]uint, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint32
 	var mv uint
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint32(dd.DecodeUint(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32Uint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint32]uint8)
-		v, changed := fastpathTV.DecMapUint32Uint8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint32Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]uint8)
+		v, changed := fastpathTV.DecMapUint32Uint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint32]uint8)
-		fastpathTV.DecMapUint32Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint32Uint8V(rv2i(rv).(map[uint32]uint8), false, d)
 	}
 }
-func (f fastpathT) DecMapUint32Uint8X(vp *map[uint32]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32Uint8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint32Uint8X(vp *map[uint32]uint8, d *Decoder) {
+	v, changed := f.DecMapUint32Uint8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32Uint8V(v map[uint32]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32Uint8V(v map[uint32]uint8, canChange bool,
 	d *Decoder) (_ map[uint32]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
@@ -27138,63 +24661,58 @@ func (_ fastpathT) DecMapUint32Uint8V(v map[uint32]uint8, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint32
 	var mv uint8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint32(dd.DecodeUint(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint8(dd.DecodeUint(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32Uint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint32]uint16)
-		v, changed := fastpathTV.DecMapUint32Uint16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint32Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]uint16)
+		v, changed := fastpathTV.DecMapUint32Uint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint32]uint16)
-		fastpathTV.DecMapUint32Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint32Uint16V(rv2i(rv).(map[uint32]uint16), false, d)
 	}
 }
-func (f fastpathT) DecMapUint32Uint16X(vp *map[uint32]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32Uint16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint32Uint16X(vp *map[uint32]uint16, d *Decoder) {
+	v, changed := f.DecMapUint32Uint16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32Uint16V(v map[uint32]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32Uint16V(v map[uint32]uint16, canChange bool,
 	d *Decoder) (_ map[uint32]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
@@ -27202,63 +24720,58 @@ func (_ fastpathT) DecMapUint32Uint16V(v map[uint32]uint16, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint32
 	var mv uint16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint32(dd.DecodeUint(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint16(dd.DecodeUint(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32Uint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint32]uint32)
-		v, changed := fastpathTV.DecMapUint32Uint32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint32Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]uint32)
+		v, changed := fastpathTV.DecMapUint32Uint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint32]uint32)
-		fastpathTV.DecMapUint32Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint32Uint32V(rv2i(rv).(map[uint32]uint32), false, d)
 	}
 }
-func (f fastpathT) DecMapUint32Uint32X(vp *map[uint32]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32Uint32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint32Uint32X(vp *map[uint32]uint32, d *Decoder) {
+	v, changed := f.DecMapUint32Uint32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32Uint32V(v map[uint32]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32Uint32V(v map[uint32]uint32, canChange bool,
 	d *Decoder) (_ map[uint32]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
@@ -27266,63 +24779,58 @@ func (_ fastpathT) DecMapUint32Uint32V(v map[uint32]uint32, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint32
 	var mv uint32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint32(dd.DecodeUint(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint32(dd.DecodeUint(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32Uint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint32]uint64)
-		v, changed := fastpathTV.DecMapUint32Uint64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint32Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]uint64)
+		v, changed := fastpathTV.DecMapUint32Uint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint32]uint64)
-		fastpathTV.DecMapUint32Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint32Uint64V(rv2i(rv).(map[uint32]uint64), false, d)
 	}
 }
-func (f fastpathT) DecMapUint32Uint64X(vp *map[uint32]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32Uint64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint32Uint64X(vp *map[uint32]uint64, d *Decoder) {
+	v, changed := f.DecMapUint32Uint64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32Uint64V(v map[uint32]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32Uint64V(v map[uint32]uint64, canChange bool,
 	d *Decoder) (_ map[uint32]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -27330,63 +24838,58 @@ func (_ fastpathT) DecMapUint32Uint64V(v map[uint32]uint64, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint32
 	var mv uint64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint32(dd.DecodeUint(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeUint(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32UintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint32]uintptr)
-		v, changed := fastpathTV.DecMapUint32UintptrV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint32UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]uintptr)
+		v, changed := fastpathTV.DecMapUint32UintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint32]uintptr)
-		fastpathTV.DecMapUint32UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint32UintptrV(rv2i(rv).(map[uint32]uintptr), false, d)
 	}
 }
-func (f fastpathT) DecMapUint32UintptrX(vp *map[uint32]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32UintptrV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint32UintptrX(vp *map[uint32]uintptr, d *Decoder) {
+	v, changed := f.DecMapUint32UintptrV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32UintptrV(v map[uint32]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32UintptrV(v map[uint32]uintptr, canChange bool,
 	d *Decoder) (_ map[uint32]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -27394,63 +24897,58 @@ func (_ fastpathT) DecMapUint32UintptrV(v map[uint32]uintptr, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint32
 	var mv uintptr
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint32(dd.DecodeUint(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uintptr(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32IntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint32]int)
-		v, changed := fastpathTV.DecMapUint32IntV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint32IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]int)
+		v, changed := fastpathTV.DecMapUint32IntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint32]int)
-		fastpathTV.DecMapUint32IntV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint32IntV(rv2i(rv).(map[uint32]int), false, d)
 	}
 }
-func (f fastpathT) DecMapUint32IntX(vp *map[uint32]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32IntV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint32IntX(vp *map[uint32]int, d *Decoder) {
+	v, changed := f.DecMapUint32IntV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32IntV(v map[uint32]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32IntV(v map[uint32]int, canChange bool,
 	d *Decoder) (_ map[uint32]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -27458,63 +24956,58 @@ func (_ fastpathT) DecMapUint32IntV(v map[uint32]int, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint32
 	var mv int
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint32(dd.DecodeUint(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int(dd.DecodeInt(intBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32Int8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint32]int8)
-		v, changed := fastpathTV.DecMapUint32Int8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint32Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]int8)
+		v, changed := fastpathTV.DecMapUint32Int8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint32]int8)
-		fastpathTV.DecMapUint32Int8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint32Int8V(rv2i(rv).(map[uint32]int8), false, d)
 	}
 }
-func (f fastpathT) DecMapUint32Int8X(vp *map[uint32]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32Int8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint32Int8X(vp *map[uint32]int8, d *Decoder) {
+	v, changed := f.DecMapUint32Int8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32Int8V(v map[uint32]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32Int8V(v map[uint32]int8, canChange bool,
 	d *Decoder) (_ map[uint32]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
@@ -27522,63 +25015,58 @@ func (_ fastpathT) DecMapUint32Int8V(v map[uint32]int8, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint32
 	var mv int8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint32(dd.DecodeUint(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int8(dd.DecodeInt(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32Int16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint32]int16)
-		v, changed := fastpathTV.DecMapUint32Int16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint32Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]int16)
+		v, changed := fastpathTV.DecMapUint32Int16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint32]int16)
-		fastpathTV.DecMapUint32Int16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint32Int16V(rv2i(rv).(map[uint32]int16), false, d)
 	}
 }
-func (f fastpathT) DecMapUint32Int16X(vp *map[uint32]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32Int16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint32Int16X(vp *map[uint32]int16, d *Decoder) {
+	v, changed := f.DecMapUint32Int16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32Int16V(v map[uint32]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32Int16V(v map[uint32]int16, canChange bool,
 	d *Decoder) (_ map[uint32]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
@@ -27586,63 +25074,58 @@ func (_ fastpathT) DecMapUint32Int16V(v map[uint32]int16, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint32
 	var mv int16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint32(dd.DecodeUint(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int16(dd.DecodeInt(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32Int32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint32]int32)
-		v, changed := fastpathTV.DecMapUint32Int32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint32Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]int32)
+		v, changed := fastpathTV.DecMapUint32Int32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint32]int32)
-		fastpathTV.DecMapUint32Int32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint32Int32V(rv2i(rv).(map[uint32]int32), false, d)
 	}
 }
-func (f fastpathT) DecMapUint32Int32X(vp *map[uint32]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32Int32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint32Int32X(vp *map[uint32]int32, d *Decoder) {
+	v, changed := f.DecMapUint32Int32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32Int32V(v map[uint32]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32Int32V(v map[uint32]int32, canChange bool,
 	d *Decoder) (_ map[uint32]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
@@ -27650,63 +25133,58 @@ func (_ fastpathT) DecMapUint32Int32V(v map[uint32]int32, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint32
 	var mv int32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint32(dd.DecodeUint(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int32(dd.DecodeInt(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32Int64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint32]int64)
-		v, changed := fastpathTV.DecMapUint32Int64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint32Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]int64)
+		v, changed := fastpathTV.DecMapUint32Int64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint32]int64)
-		fastpathTV.DecMapUint32Int64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint32Int64V(rv2i(rv).(map[uint32]int64), false, d)
 	}
 }
-func (f fastpathT) DecMapUint32Int64X(vp *map[uint32]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32Int64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint32Int64X(vp *map[uint32]int64, d *Decoder) {
+	v, changed := f.DecMapUint32Int64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32Int64V(v map[uint32]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32Int64V(v map[uint32]int64, canChange bool,
 	d *Decoder) (_ map[uint32]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -27714,63 +25192,58 @@ func (_ fastpathT) DecMapUint32Int64V(v map[uint32]int64, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint32
 	var mv int64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint32(dd.DecodeUint(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeInt(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32Float32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint32]float32)
-		v, changed := fastpathTV.DecMapUint32Float32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint32Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]float32)
+		v, changed := fastpathTV.DecMapUint32Float32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint32]float32)
-		fastpathTV.DecMapUint32Float32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint32Float32V(rv2i(rv).(map[uint32]float32), false, d)
 	}
 }
-func (f fastpathT) DecMapUint32Float32X(vp *map[uint32]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32Float32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint32Float32X(vp *map[uint32]float32, d *Decoder) {
+	v, changed := f.DecMapUint32Float32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32Float32V(v map[uint32]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32Float32V(v map[uint32]float32, canChange bool,
 	d *Decoder) (_ map[uint32]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
@@ -27778,63 +25251,58 @@ func (_ fastpathT) DecMapUint32Float32V(v map[uint32]float32, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint32
 	var mv float32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint32(dd.DecodeUint(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = float32(dd.DecodeFloat(true))
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = float32(chkFloat32(dd.DecodeFloat64()))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32Float64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint32]float64)
-		v, changed := fastpathTV.DecMapUint32Float64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint32Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]float64)
+		v, changed := fastpathTV.DecMapUint32Float64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint32]float64)
-		fastpathTV.DecMapUint32Float64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint32Float64V(rv2i(rv).(map[uint32]float64), false, d)
 	}
 }
-func (f fastpathT) DecMapUint32Float64X(vp *map[uint32]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32Float64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint32Float64X(vp *map[uint32]float64, d *Decoder) {
+	v, changed := f.DecMapUint32Float64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32Float64V(v map[uint32]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32Float64V(v map[uint32]float64, canChange bool,
 	d *Decoder) (_ map[uint32]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -27842,63 +25310,58 @@ func (_ fastpathT) DecMapUint32Float64V(v map[uint32]float64, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint32
 	var mv float64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint32(dd.DecodeUint(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = dd.DecodeFloat(false)
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint32BoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint32]bool)
-		v, changed := fastpathTV.DecMapUint32BoolV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint32BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]bool)
+		v, changed := fastpathTV.DecMapUint32BoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint32]bool)
-		fastpathTV.DecMapUint32BoolV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint32BoolV(rv2i(rv).(map[uint32]bool), false, d)
 	}
 }
-func (f fastpathT) DecMapUint32BoolX(vp *map[uint32]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint32BoolV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint32BoolX(vp *map[uint32]bool, d *Decoder) {
+	v, changed := f.DecMapUint32BoolV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint32BoolV(v map[uint32]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint32BoolV(v map[uint32]bool, canChange bool,
 	d *Decoder) (_ map[uint32]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
@@ -27906,63 +25369,58 @@ func (_ fastpathT) DecMapUint32BoolV(v map[uint32]bool, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint32
 	var mv bool
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uint32(dd.DecodeUint(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
+			}
+			continue
 		}
 		mv = dd.DecodeBool()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64IntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint64]interface{})
-		v, changed := fastpathTV.DecMapUint64IntfV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint64IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]interface{})
+		v, changed := fastpathTV.DecMapUint64IntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint64]interface{})
-		fastpathTV.DecMapUint64IntfV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint64IntfV(rv2i(rv).(map[uint64]interface{}), false, d)
 	}
 }
-func (f fastpathT) DecMapUint64IntfX(vp *map[uint64]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64IntfV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint64IntfX(vp *map[uint64]interface{}, d *Decoder) {
+	v, changed := f.DecMapUint64IntfV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64IntfV(v map[uint64]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64IntfV(v map[uint64]interface{}, canChange bool,
 	d *Decoder) (_ map[uint64]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -27970,22 +25428,29 @@ func (_ fastpathT) DecMapUint64IntfV(v map[uint64]interface{}, checkNil bool, ca
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk uint64
 	var mv interface{}
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeUint(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = nil
+			}
+			continue
 		}
 		if mapGet {
 			mv = v[mk]
@@ -27997,41 +25462,30 @@ func (_ fastpathT) DecMapUint64IntfV(v map[uint64]interface{}, checkNil bool, ca
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64StringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint64]string)
-		v, changed := fastpathTV.DecMapUint64StringV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint64StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]string)
+		v, changed := fastpathTV.DecMapUint64StringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint64]string)
-		fastpathTV.DecMapUint64StringV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint64StringV(rv2i(rv).(map[uint64]string), false, d)
 	}
 }
-func (f fastpathT) DecMapUint64StringX(vp *map[uint64]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64StringV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint64StringX(vp *map[uint64]string, d *Decoder) {
+	v, changed := f.DecMapUint64StringV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64StringV(v map[uint64]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64StringV(v map[uint64]string, canChange bool,
 	d *Decoder) (_ map[uint64]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -28039,63 +25493,58 @@ func (_ fastpathT) DecMapUint64StringV(v map[uint64]string, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint64
 	var mv string
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeUint(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
+			}
+			continue
 		}
 		mv = dd.DecodeString()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64UintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint64]uint)
-		v, changed := fastpathTV.DecMapUint64UintV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint64UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]uint)
+		v, changed := fastpathTV.DecMapUint64UintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint64]uint)
-		fastpathTV.DecMapUint64UintV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint64UintV(rv2i(rv).(map[uint64]uint), false, d)
 	}
 }
-func (f fastpathT) DecMapUint64UintX(vp *map[uint64]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64UintV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint64UintX(vp *map[uint64]uint, d *Decoder) {
+	v, changed := f.DecMapUint64UintV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64UintV(v map[uint64]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64UintV(v map[uint64]uint, canChange bool,
 	d *Decoder) (_ map[uint64]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -28103,63 +25552,58 @@ func (_ fastpathT) DecMapUint64UintV(v map[uint64]uint, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint64
 	var mv uint
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeUint(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64Uint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint64]uint8)
-		v, changed := fastpathTV.DecMapUint64Uint8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint64Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]uint8)
+		v, changed := fastpathTV.DecMapUint64Uint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint64]uint8)
-		fastpathTV.DecMapUint64Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint64Uint8V(rv2i(rv).(map[uint64]uint8), false, d)
 	}
 }
-func (f fastpathT) DecMapUint64Uint8X(vp *map[uint64]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64Uint8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint64Uint8X(vp *map[uint64]uint8, d *Decoder) {
+	v, changed := f.DecMapUint64Uint8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64Uint8V(v map[uint64]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64Uint8V(v map[uint64]uint8, canChange bool,
 	d *Decoder) (_ map[uint64]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -28167,63 +25611,58 @@ func (_ fastpathT) DecMapUint64Uint8V(v map[uint64]uint8, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint64
 	var mv uint8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeUint(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint8(dd.DecodeUint(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64Uint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint64]uint16)
-		v, changed := fastpathTV.DecMapUint64Uint16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint64Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]uint16)
+		v, changed := fastpathTV.DecMapUint64Uint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint64]uint16)
-		fastpathTV.DecMapUint64Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint64Uint16V(rv2i(rv).(map[uint64]uint16), false, d)
 	}
 }
-func (f fastpathT) DecMapUint64Uint16X(vp *map[uint64]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64Uint16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint64Uint16X(vp *map[uint64]uint16, d *Decoder) {
+	v, changed := f.DecMapUint64Uint16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64Uint16V(v map[uint64]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64Uint16V(v map[uint64]uint16, canChange bool,
 	d *Decoder) (_ map[uint64]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -28231,63 +25670,58 @@ func (_ fastpathT) DecMapUint64Uint16V(v map[uint64]uint16, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint64
 	var mv uint16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeUint(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint16(dd.DecodeUint(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64Uint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint64]uint32)
-		v, changed := fastpathTV.DecMapUint64Uint32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint64Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]uint32)
+		v, changed := fastpathTV.DecMapUint64Uint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint64]uint32)
-		fastpathTV.DecMapUint64Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint64Uint32V(rv2i(rv).(map[uint64]uint32), false, d)
 	}
 }
-func (f fastpathT) DecMapUint64Uint32X(vp *map[uint64]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64Uint32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint64Uint32X(vp *map[uint64]uint32, d *Decoder) {
+	v, changed := f.DecMapUint64Uint32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64Uint32V(v map[uint64]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64Uint32V(v map[uint64]uint32, canChange bool,
 	d *Decoder) (_ map[uint64]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -28295,63 +25729,58 @@ func (_ fastpathT) DecMapUint64Uint32V(v map[uint64]uint32, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint64
 	var mv uint32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeUint(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint32(dd.DecodeUint(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64Uint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint64]uint64)
-		v, changed := fastpathTV.DecMapUint64Uint64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint64Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]uint64)
+		v, changed := fastpathTV.DecMapUint64Uint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint64]uint64)
-		fastpathTV.DecMapUint64Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint64Uint64V(rv2i(rv).(map[uint64]uint64), false, d)
 	}
 }
-func (f fastpathT) DecMapUint64Uint64X(vp *map[uint64]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64Uint64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint64Uint64X(vp *map[uint64]uint64, d *Decoder) {
+	v, changed := f.DecMapUint64Uint64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64Uint64V(v map[uint64]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64Uint64V(v map[uint64]uint64, canChange bool,
 	d *Decoder) (_ map[uint64]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -28359,63 +25788,58 @@ func (_ fastpathT) DecMapUint64Uint64V(v map[uint64]uint64, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint64
 	var mv uint64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeUint(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeUint(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64UintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint64]uintptr)
-		v, changed := fastpathTV.DecMapUint64UintptrV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint64UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]uintptr)
+		v, changed := fastpathTV.DecMapUint64UintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint64]uintptr)
-		fastpathTV.DecMapUint64UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint64UintptrV(rv2i(rv).(map[uint64]uintptr), false, d)
 	}
 }
-func (f fastpathT) DecMapUint64UintptrX(vp *map[uint64]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64UintptrV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint64UintptrX(vp *map[uint64]uintptr, d *Decoder) {
+	v, changed := f.DecMapUint64UintptrV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64UintptrV(v map[uint64]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64UintptrV(v map[uint64]uintptr, canChange bool,
 	d *Decoder) (_ map[uint64]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -28423,63 +25847,58 @@ func (_ fastpathT) DecMapUint64UintptrV(v map[uint64]uintptr, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint64
 	var mv uintptr
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeUint(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uintptr(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64IntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint64]int)
-		v, changed := fastpathTV.DecMapUint64IntV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint64IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]int)
+		v, changed := fastpathTV.DecMapUint64IntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint64]int)
-		fastpathTV.DecMapUint64IntV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint64IntV(rv2i(rv).(map[uint64]int), false, d)
 	}
 }
-func (f fastpathT) DecMapUint64IntX(vp *map[uint64]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64IntV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint64IntX(vp *map[uint64]int, d *Decoder) {
+	v, changed := f.DecMapUint64IntV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64IntV(v map[uint64]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64IntV(v map[uint64]int, canChange bool,
 	d *Decoder) (_ map[uint64]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -28487,63 +25906,58 @@ func (_ fastpathT) DecMapUint64IntV(v map[uint64]int, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint64
 	var mv int
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeUint(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int(dd.DecodeInt(intBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64Int8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint64]int8)
-		v, changed := fastpathTV.DecMapUint64Int8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint64Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]int8)
+		v, changed := fastpathTV.DecMapUint64Int8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint64]int8)
-		fastpathTV.DecMapUint64Int8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint64Int8V(rv2i(rv).(map[uint64]int8), false, d)
 	}
 }
-func (f fastpathT) DecMapUint64Int8X(vp *map[uint64]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64Int8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint64Int8X(vp *map[uint64]int8, d *Decoder) {
+	v, changed := f.DecMapUint64Int8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64Int8V(v map[uint64]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64Int8V(v map[uint64]int8, canChange bool,
 	d *Decoder) (_ map[uint64]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -28551,63 +25965,58 @@ func (_ fastpathT) DecMapUint64Int8V(v map[uint64]int8, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint64
 	var mv int8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeUint(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int8(dd.DecodeInt(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64Int16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint64]int16)
-		v, changed := fastpathTV.DecMapUint64Int16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint64Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]int16)
+		v, changed := fastpathTV.DecMapUint64Int16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint64]int16)
-		fastpathTV.DecMapUint64Int16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint64Int16V(rv2i(rv).(map[uint64]int16), false, d)
 	}
 }
-func (f fastpathT) DecMapUint64Int16X(vp *map[uint64]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64Int16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint64Int16X(vp *map[uint64]int16, d *Decoder) {
+	v, changed := f.DecMapUint64Int16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64Int16V(v map[uint64]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64Int16V(v map[uint64]int16, canChange bool,
 	d *Decoder) (_ map[uint64]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -28615,63 +26024,58 @@ func (_ fastpathT) DecMapUint64Int16V(v map[uint64]int16, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint64
 	var mv int16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeUint(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int16(dd.DecodeInt(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64Int32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint64]int32)
-		v, changed := fastpathTV.DecMapUint64Int32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint64Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]int32)
+		v, changed := fastpathTV.DecMapUint64Int32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint64]int32)
-		fastpathTV.DecMapUint64Int32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint64Int32V(rv2i(rv).(map[uint64]int32), false, d)
 	}
 }
-func (f fastpathT) DecMapUint64Int32X(vp *map[uint64]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64Int32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint64Int32X(vp *map[uint64]int32, d *Decoder) {
+	v, changed := f.DecMapUint64Int32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64Int32V(v map[uint64]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64Int32V(v map[uint64]int32, canChange bool,
 	d *Decoder) (_ map[uint64]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -28679,63 +26083,58 @@ func (_ fastpathT) DecMapUint64Int32V(v map[uint64]int32, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint64
 	var mv int32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeUint(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int32(dd.DecodeInt(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64Int64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint64]int64)
-		v, changed := fastpathTV.DecMapUint64Int64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint64Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]int64)
+		v, changed := fastpathTV.DecMapUint64Int64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint64]int64)
-		fastpathTV.DecMapUint64Int64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint64Int64V(rv2i(rv).(map[uint64]int64), false, d)
 	}
 }
-func (f fastpathT) DecMapUint64Int64X(vp *map[uint64]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64Int64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint64Int64X(vp *map[uint64]int64, d *Decoder) {
+	v, changed := f.DecMapUint64Int64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64Int64V(v map[uint64]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64Int64V(v map[uint64]int64, canChange bool,
 	d *Decoder) (_ map[uint64]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -28743,63 +26142,58 @@ func (_ fastpathT) DecMapUint64Int64V(v map[uint64]int64, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint64
 	var mv int64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeUint(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeInt(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64Float32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint64]float32)
-		v, changed := fastpathTV.DecMapUint64Float32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint64Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]float32)
+		v, changed := fastpathTV.DecMapUint64Float32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint64]float32)
-		fastpathTV.DecMapUint64Float32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint64Float32V(rv2i(rv).(map[uint64]float32), false, d)
 	}
 }
-func (f fastpathT) DecMapUint64Float32X(vp *map[uint64]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64Float32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint64Float32X(vp *map[uint64]float32, d *Decoder) {
+	v, changed := f.DecMapUint64Float32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64Float32V(v map[uint64]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64Float32V(v map[uint64]float32, canChange bool,
 	d *Decoder) (_ map[uint64]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -28807,63 +26201,58 @@ func (_ fastpathT) DecMapUint64Float32V(v map[uint64]float32, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint64
 	var mv float32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeUint(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = float32(dd.DecodeFloat(true))
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = float32(chkFloat32(dd.DecodeFloat64()))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64Float64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint64]float64)
-		v, changed := fastpathTV.DecMapUint64Float64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint64Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]float64)
+		v, changed := fastpathTV.DecMapUint64Float64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint64]float64)
-		fastpathTV.DecMapUint64Float64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint64Float64V(rv2i(rv).(map[uint64]float64), false, d)
 	}
 }
-func (f fastpathT) DecMapUint64Float64X(vp *map[uint64]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64Float64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint64Float64X(vp *map[uint64]float64, d *Decoder) {
+	v, changed := f.DecMapUint64Float64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64Float64V(v map[uint64]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64Float64V(v map[uint64]float64, canChange bool,
 	d *Decoder) (_ map[uint64]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -28871,63 +26260,58 @@ func (_ fastpathT) DecMapUint64Float64V(v map[uint64]float64, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint64
 	var mv float64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeUint(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = dd.DecodeFloat(false)
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUint64BoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uint64]bool)
-		v, changed := fastpathTV.DecMapUint64BoolV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUint64BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]bool)
+		v, changed := fastpathTV.DecMapUint64BoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uint64]bool)
-		fastpathTV.DecMapUint64BoolV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUint64BoolV(rv2i(rv).(map[uint64]bool), false, d)
 	}
 }
-func (f fastpathT) DecMapUint64BoolX(vp *map[uint64]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUint64BoolV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUint64BoolX(vp *map[uint64]bool, d *Decoder) {
+	v, changed := f.DecMapUint64BoolV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUint64BoolV(v map[uint64]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUint64BoolV(v map[uint64]bool, canChange bool,
 	d *Decoder) (_ map[uint64]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -28935,63 +26319,58 @@ func (_ fastpathT) DecMapUint64BoolV(v map[uint64]bool, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uint64
 	var mv bool
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeUint(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
+			}
+			continue
 		}
 		mv = dd.DecodeBool()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrIntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uintptr]interface{})
-		v, changed := fastpathTV.DecMapUintptrIntfV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintptrIntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]interface{})
+		v, changed := fastpathTV.DecMapUintptrIntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uintptr]interface{})
-		fastpathTV.DecMapUintptrIntfV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintptrIntfV(rv2i(rv).(map[uintptr]interface{}), false, d)
 	}
 }
-func (f fastpathT) DecMapUintptrIntfX(vp *map[uintptr]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrIntfV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintptrIntfX(vp *map[uintptr]interface{}, d *Decoder) {
+	v, changed := f.DecMapUintptrIntfV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrIntfV(v map[uintptr]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrIntfV(v map[uintptr]interface{}, canChange bool,
 	d *Decoder) (_ map[uintptr]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -28999,22 +26378,29 @@ func (_ fastpathT) DecMapUintptrIntfV(v map[uintptr]interface{}, checkNil bool,
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk uintptr
 	var mv interface{}
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uintptr(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = nil
+			}
+			continue
 		}
 		if mapGet {
 			mv = v[mk]
@@ -29026,41 +26412,30 @@ func (_ fastpathT) DecMapUintptrIntfV(v map[uintptr]interface{}, checkNil bool,
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrStringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uintptr]string)
-		v, changed := fastpathTV.DecMapUintptrStringV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintptrStringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]string)
+		v, changed := fastpathTV.DecMapUintptrStringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uintptr]string)
-		fastpathTV.DecMapUintptrStringV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintptrStringV(rv2i(rv).(map[uintptr]string), false, d)
 	}
 }
-func (f fastpathT) DecMapUintptrStringX(vp *map[uintptr]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrStringV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintptrStringX(vp *map[uintptr]string, d *Decoder) {
+	v, changed := f.DecMapUintptrStringV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrStringV(v map[uintptr]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrStringV(v map[uintptr]string, canChange bool,
 	d *Decoder) (_ map[uintptr]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -29068,63 +26443,58 @@ func (_ fastpathT) DecMapUintptrStringV(v map[uintptr]string, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uintptr
 	var mv string
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uintptr(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
+			}
+			continue
 		}
 		mv = dd.DecodeString()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrUintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uintptr]uint)
-		v, changed := fastpathTV.DecMapUintptrUintV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintptrUintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]uint)
+		v, changed := fastpathTV.DecMapUintptrUintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uintptr]uint)
-		fastpathTV.DecMapUintptrUintV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintptrUintV(rv2i(rv).(map[uintptr]uint), false, d)
 	}
 }
-func (f fastpathT) DecMapUintptrUintX(vp *map[uintptr]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrUintV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintptrUintX(vp *map[uintptr]uint, d *Decoder) {
+	v, changed := f.DecMapUintptrUintV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrUintV(v map[uintptr]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrUintV(v map[uintptr]uint, canChange bool,
 	d *Decoder) (_ map[uintptr]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -29132,63 +26502,58 @@ func (_ fastpathT) DecMapUintptrUintV(v map[uintptr]uint, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uintptr
 	var mv uint
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uintptr(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrUint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uintptr]uint8)
-		v, changed := fastpathTV.DecMapUintptrUint8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintptrUint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]uint8)
+		v, changed := fastpathTV.DecMapUintptrUint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uintptr]uint8)
-		fastpathTV.DecMapUintptrUint8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintptrUint8V(rv2i(rv).(map[uintptr]uint8), false, d)
 	}
 }
-func (f fastpathT) DecMapUintptrUint8X(vp *map[uintptr]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrUint8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintptrUint8X(vp *map[uintptr]uint8, d *Decoder) {
+	v, changed := f.DecMapUintptrUint8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrUint8V(v map[uintptr]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrUint8V(v map[uintptr]uint8, canChange bool,
 	d *Decoder) (_ map[uintptr]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -29196,63 +26561,58 @@ func (_ fastpathT) DecMapUintptrUint8V(v map[uintptr]uint8, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uintptr
 	var mv uint8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uintptr(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint8(dd.DecodeUint(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrUint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uintptr]uint16)
-		v, changed := fastpathTV.DecMapUintptrUint16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintptrUint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]uint16)
+		v, changed := fastpathTV.DecMapUintptrUint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uintptr]uint16)
-		fastpathTV.DecMapUintptrUint16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintptrUint16V(rv2i(rv).(map[uintptr]uint16), false, d)
 	}
 }
-func (f fastpathT) DecMapUintptrUint16X(vp *map[uintptr]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrUint16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintptrUint16X(vp *map[uintptr]uint16, d *Decoder) {
+	v, changed := f.DecMapUintptrUint16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrUint16V(v map[uintptr]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrUint16V(v map[uintptr]uint16, canChange bool,
 	d *Decoder) (_ map[uintptr]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -29260,63 +26620,58 @@ func (_ fastpathT) DecMapUintptrUint16V(v map[uintptr]uint16, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uintptr
 	var mv uint16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uintptr(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint16(dd.DecodeUint(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrUint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uintptr]uint32)
-		v, changed := fastpathTV.DecMapUintptrUint32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintptrUint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]uint32)
+		v, changed := fastpathTV.DecMapUintptrUint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uintptr]uint32)
-		fastpathTV.DecMapUintptrUint32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintptrUint32V(rv2i(rv).(map[uintptr]uint32), false, d)
 	}
 }
-func (f fastpathT) DecMapUintptrUint32X(vp *map[uintptr]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrUint32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintptrUint32X(vp *map[uintptr]uint32, d *Decoder) {
+	v, changed := f.DecMapUintptrUint32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrUint32V(v map[uintptr]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrUint32V(v map[uintptr]uint32, canChange bool,
 	d *Decoder) (_ map[uintptr]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -29324,63 +26679,58 @@ func (_ fastpathT) DecMapUintptrUint32V(v map[uintptr]uint32, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uintptr
 	var mv uint32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uintptr(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint32(dd.DecodeUint(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrUint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uintptr]uint64)
-		v, changed := fastpathTV.DecMapUintptrUint64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintptrUint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]uint64)
+		v, changed := fastpathTV.DecMapUintptrUint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uintptr]uint64)
-		fastpathTV.DecMapUintptrUint64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintptrUint64V(rv2i(rv).(map[uintptr]uint64), false, d)
 	}
 }
-func (f fastpathT) DecMapUintptrUint64X(vp *map[uintptr]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrUint64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintptrUint64X(vp *map[uintptr]uint64, d *Decoder) {
+	v, changed := f.DecMapUintptrUint64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrUint64V(v map[uintptr]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrUint64V(v map[uintptr]uint64, canChange bool,
 	d *Decoder) (_ map[uintptr]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -29388,63 +26738,58 @@ func (_ fastpathT) DecMapUintptrUint64V(v map[uintptr]uint64, checkNil bool, can
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uintptr
 	var mv uint64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uintptr(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeUint(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrUintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uintptr]uintptr)
-		v, changed := fastpathTV.DecMapUintptrUintptrV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintptrUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]uintptr)
+		v, changed := fastpathTV.DecMapUintptrUintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uintptr]uintptr)
-		fastpathTV.DecMapUintptrUintptrV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintptrUintptrV(rv2i(rv).(map[uintptr]uintptr), false, d)
 	}
 }
-func (f fastpathT) DecMapUintptrUintptrX(vp *map[uintptr]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrUintptrV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintptrUintptrX(vp *map[uintptr]uintptr, d *Decoder) {
+	v, changed := f.DecMapUintptrUintptrV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrUintptrV(v map[uintptr]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrUintptrV(v map[uintptr]uintptr, canChange bool,
 	d *Decoder) (_ map[uintptr]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -29452,63 +26797,58 @@ func (_ fastpathT) DecMapUintptrUintptrV(v map[uintptr]uintptr, checkNil bool, c
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uintptr
 	var mv uintptr
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uintptr(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uintptr(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrIntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uintptr]int)
-		v, changed := fastpathTV.DecMapUintptrIntV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintptrIntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]int)
+		v, changed := fastpathTV.DecMapUintptrIntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uintptr]int)
-		fastpathTV.DecMapUintptrIntV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintptrIntV(rv2i(rv).(map[uintptr]int), false, d)
 	}
 }
-func (f fastpathT) DecMapUintptrIntX(vp *map[uintptr]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrIntV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintptrIntX(vp *map[uintptr]int, d *Decoder) {
+	v, changed := f.DecMapUintptrIntV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrIntV(v map[uintptr]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrIntV(v map[uintptr]int, canChange bool,
 	d *Decoder) (_ map[uintptr]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -29516,63 +26856,58 @@ func (_ fastpathT) DecMapUintptrIntV(v map[uintptr]int, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uintptr
 	var mv int
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uintptr(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int(dd.DecodeInt(intBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrInt8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uintptr]int8)
-		v, changed := fastpathTV.DecMapUintptrInt8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintptrInt8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]int8)
+		v, changed := fastpathTV.DecMapUintptrInt8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uintptr]int8)
-		fastpathTV.DecMapUintptrInt8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintptrInt8V(rv2i(rv).(map[uintptr]int8), false, d)
 	}
 }
-func (f fastpathT) DecMapUintptrInt8X(vp *map[uintptr]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrInt8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintptrInt8X(vp *map[uintptr]int8, d *Decoder) {
+	v, changed := f.DecMapUintptrInt8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrInt8V(v map[uintptr]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrInt8V(v map[uintptr]int8, canChange bool,
 	d *Decoder) (_ map[uintptr]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -29580,63 +26915,58 @@ func (_ fastpathT) DecMapUintptrInt8V(v map[uintptr]int8, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uintptr
 	var mv int8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uintptr(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int8(dd.DecodeInt(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrInt16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uintptr]int16)
-		v, changed := fastpathTV.DecMapUintptrInt16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintptrInt16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]int16)
+		v, changed := fastpathTV.DecMapUintptrInt16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uintptr]int16)
-		fastpathTV.DecMapUintptrInt16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintptrInt16V(rv2i(rv).(map[uintptr]int16), false, d)
 	}
 }
-func (f fastpathT) DecMapUintptrInt16X(vp *map[uintptr]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrInt16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintptrInt16X(vp *map[uintptr]int16, d *Decoder) {
+	v, changed := f.DecMapUintptrInt16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrInt16V(v map[uintptr]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrInt16V(v map[uintptr]int16, canChange bool,
 	d *Decoder) (_ map[uintptr]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -29644,63 +26974,58 @@ func (_ fastpathT) DecMapUintptrInt16V(v map[uintptr]int16, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uintptr
 	var mv int16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uintptr(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int16(dd.DecodeInt(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrInt32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uintptr]int32)
-		v, changed := fastpathTV.DecMapUintptrInt32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintptrInt32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]int32)
+		v, changed := fastpathTV.DecMapUintptrInt32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uintptr]int32)
-		fastpathTV.DecMapUintptrInt32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintptrInt32V(rv2i(rv).(map[uintptr]int32), false, d)
 	}
 }
-func (f fastpathT) DecMapUintptrInt32X(vp *map[uintptr]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrInt32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintptrInt32X(vp *map[uintptr]int32, d *Decoder) {
+	v, changed := f.DecMapUintptrInt32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrInt32V(v map[uintptr]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrInt32V(v map[uintptr]int32, canChange bool,
 	d *Decoder) (_ map[uintptr]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -29708,63 +27033,58 @@ func (_ fastpathT) DecMapUintptrInt32V(v map[uintptr]int32, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uintptr
 	var mv int32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uintptr(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int32(dd.DecodeInt(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrInt64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uintptr]int64)
-		v, changed := fastpathTV.DecMapUintptrInt64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintptrInt64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]int64)
+		v, changed := fastpathTV.DecMapUintptrInt64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uintptr]int64)
-		fastpathTV.DecMapUintptrInt64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintptrInt64V(rv2i(rv).(map[uintptr]int64), false, d)
 	}
 }
-func (f fastpathT) DecMapUintptrInt64X(vp *map[uintptr]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrInt64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintptrInt64X(vp *map[uintptr]int64, d *Decoder) {
+	v, changed := f.DecMapUintptrInt64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrInt64V(v map[uintptr]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrInt64V(v map[uintptr]int64, canChange bool,
 	d *Decoder) (_ map[uintptr]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -29772,63 +27092,58 @@ func (_ fastpathT) DecMapUintptrInt64V(v map[uintptr]int64, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uintptr
 	var mv int64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uintptr(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeInt(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrFloat32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uintptr]float32)
-		v, changed := fastpathTV.DecMapUintptrFloat32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintptrFloat32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]float32)
+		v, changed := fastpathTV.DecMapUintptrFloat32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uintptr]float32)
-		fastpathTV.DecMapUintptrFloat32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintptrFloat32V(rv2i(rv).(map[uintptr]float32), false, d)
 	}
 }
-func (f fastpathT) DecMapUintptrFloat32X(vp *map[uintptr]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrFloat32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintptrFloat32X(vp *map[uintptr]float32, d *Decoder) {
+	v, changed := f.DecMapUintptrFloat32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrFloat32V(v map[uintptr]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrFloat32V(v map[uintptr]float32, canChange bool,
 	d *Decoder) (_ map[uintptr]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -29836,63 +27151,58 @@ func (_ fastpathT) DecMapUintptrFloat32V(v map[uintptr]float32, checkNil bool, c
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uintptr
 	var mv float32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uintptr(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = float32(dd.DecodeFloat(true))
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = float32(chkFloat32(dd.DecodeFloat64()))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrFloat64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uintptr]float64)
-		v, changed := fastpathTV.DecMapUintptrFloat64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintptrFloat64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]float64)
+		v, changed := fastpathTV.DecMapUintptrFloat64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uintptr]float64)
-		fastpathTV.DecMapUintptrFloat64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintptrFloat64V(rv2i(rv).(map[uintptr]float64), false, d)
 	}
 }
-func (f fastpathT) DecMapUintptrFloat64X(vp *map[uintptr]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrFloat64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintptrFloat64X(vp *map[uintptr]float64, d *Decoder) {
+	v, changed := f.DecMapUintptrFloat64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrFloat64V(v map[uintptr]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrFloat64V(v map[uintptr]float64, canChange bool,
 	d *Decoder) (_ map[uintptr]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -29900,63 +27210,58 @@ func (_ fastpathT) DecMapUintptrFloat64V(v map[uintptr]float64, checkNil bool, c
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uintptr
 	var mv float64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uintptr(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = dd.DecodeFloat(false)
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapUintptrBoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[uintptr]bool)
-		v, changed := fastpathTV.DecMapUintptrBoolV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapUintptrBoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]bool)
+		v, changed := fastpathTV.DecMapUintptrBoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[uintptr]bool)
-		fastpathTV.DecMapUintptrBoolV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapUintptrBoolV(rv2i(rv).(map[uintptr]bool), false, d)
 	}
 }
-func (f fastpathT) DecMapUintptrBoolX(vp *map[uintptr]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapUintptrBoolV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapUintptrBoolX(vp *map[uintptr]bool, d *Decoder) {
+	v, changed := f.DecMapUintptrBoolV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapUintptrBoolV(v map[uintptr]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapUintptrBoolV(v map[uintptr]bool, canChange bool,
 	d *Decoder) (_ map[uintptr]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -29964,63 +27269,58 @@ func (_ fastpathT) DecMapUintptrBoolV(v map[uintptr]bool, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk uintptr
 	var mv bool
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = uintptr(dd.DecodeUint(uintBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
+			}
+			continue
 		}
 		mv = dd.DecodeBool()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntIntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int]interface{})
-		v, changed := fastpathTV.DecMapIntIntfV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntIntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]interface{})
+		v, changed := fastpathTV.DecMapIntIntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int]interface{})
-		fastpathTV.DecMapIntIntfV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntIntfV(rv2i(rv).(map[int]interface{}), false, d)
 	}
 }
-func (f fastpathT) DecMapIntIntfX(vp *map[int]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntIntfV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntIntfX(vp *map[int]interface{}, d *Decoder) {
+	v, changed := f.DecMapIntIntfV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntIntfV(v map[int]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntIntfV(v map[int]interface{}, canChange bool,
 	d *Decoder) (_ map[int]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -30028,22 +27328,29 @@ func (_ fastpathT) DecMapIntIntfV(v map[int]interface{}, checkNil bool, canChang
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk int
 	var mv interface{}
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int(dd.DecodeInt(intBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = nil
+			}
+			continue
 		}
 		if mapGet {
 			mv = v[mk]
@@ -30055,41 +27362,30 @@ func (_ fastpathT) DecMapIntIntfV(v map[int]interface{}, checkNil bool, canChang
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntStringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int]string)
-		v, changed := fastpathTV.DecMapIntStringV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntStringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]string)
+		v, changed := fastpathTV.DecMapIntStringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int]string)
-		fastpathTV.DecMapIntStringV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntStringV(rv2i(rv).(map[int]string), false, d)
 	}
 }
-func (f fastpathT) DecMapIntStringX(vp *map[int]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntStringV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntStringX(vp *map[int]string, d *Decoder) {
+	v, changed := f.DecMapIntStringV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntStringV(v map[int]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntStringV(v map[int]string, canChange bool,
 	d *Decoder) (_ map[int]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -30097,63 +27393,58 @@ func (_ fastpathT) DecMapIntStringV(v map[int]string, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int
 	var mv string
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int(dd.DecodeInt(intBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
+			}
+			continue
 		}
 		mv = dd.DecodeString()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntUintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int]uint)
-		v, changed := fastpathTV.DecMapIntUintV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntUintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]uint)
+		v, changed := fastpathTV.DecMapIntUintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int]uint)
-		fastpathTV.DecMapIntUintV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntUintV(rv2i(rv).(map[int]uint), false, d)
 	}
 }
-func (f fastpathT) DecMapIntUintX(vp *map[int]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntUintV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntUintX(vp *map[int]uint, d *Decoder) {
+	v, changed := f.DecMapIntUintV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntUintV(v map[int]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntUintV(v map[int]uint, canChange bool,
 	d *Decoder) (_ map[int]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -30161,63 +27452,58 @@ func (_ fastpathT) DecMapIntUintV(v map[int]uint, checkNil bool, canChange bool,
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int
 	var mv uint
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int(dd.DecodeInt(intBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntUint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int]uint8)
-		v, changed := fastpathTV.DecMapIntUint8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntUint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]uint8)
+		v, changed := fastpathTV.DecMapIntUint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int]uint8)
-		fastpathTV.DecMapIntUint8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntUint8V(rv2i(rv).(map[int]uint8), false, d)
 	}
 }
-func (f fastpathT) DecMapIntUint8X(vp *map[int]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntUint8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntUint8X(vp *map[int]uint8, d *Decoder) {
+	v, changed := f.DecMapIntUint8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntUint8V(v map[int]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntUint8V(v map[int]uint8, canChange bool,
 	d *Decoder) (_ map[int]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -30225,63 +27511,58 @@ func (_ fastpathT) DecMapIntUint8V(v map[int]uint8, checkNil bool, canChange boo
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int
 	var mv uint8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int(dd.DecodeInt(intBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint8(dd.DecodeUint(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntUint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int]uint16)
-		v, changed := fastpathTV.DecMapIntUint16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntUint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]uint16)
+		v, changed := fastpathTV.DecMapIntUint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int]uint16)
-		fastpathTV.DecMapIntUint16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntUint16V(rv2i(rv).(map[int]uint16), false, d)
 	}
 }
-func (f fastpathT) DecMapIntUint16X(vp *map[int]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntUint16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntUint16X(vp *map[int]uint16, d *Decoder) {
+	v, changed := f.DecMapIntUint16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntUint16V(v map[int]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntUint16V(v map[int]uint16, canChange bool,
 	d *Decoder) (_ map[int]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -30289,63 +27570,58 @@ func (_ fastpathT) DecMapIntUint16V(v map[int]uint16, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int
 	var mv uint16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int(dd.DecodeInt(intBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint16(dd.DecodeUint(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntUint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int]uint32)
-		v, changed := fastpathTV.DecMapIntUint32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntUint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]uint32)
+		v, changed := fastpathTV.DecMapIntUint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int]uint32)
-		fastpathTV.DecMapIntUint32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntUint32V(rv2i(rv).(map[int]uint32), false, d)
 	}
 }
-func (f fastpathT) DecMapIntUint32X(vp *map[int]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntUint32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntUint32X(vp *map[int]uint32, d *Decoder) {
+	v, changed := f.DecMapIntUint32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntUint32V(v map[int]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntUint32V(v map[int]uint32, canChange bool,
 	d *Decoder) (_ map[int]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -30353,63 +27629,58 @@ func (_ fastpathT) DecMapIntUint32V(v map[int]uint32, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int
 	var mv uint32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int(dd.DecodeInt(intBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint32(dd.DecodeUint(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntUint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int]uint64)
-		v, changed := fastpathTV.DecMapIntUint64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntUint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]uint64)
+		v, changed := fastpathTV.DecMapIntUint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int]uint64)
-		fastpathTV.DecMapIntUint64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntUint64V(rv2i(rv).(map[int]uint64), false, d)
 	}
 }
-func (f fastpathT) DecMapIntUint64X(vp *map[int]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntUint64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntUint64X(vp *map[int]uint64, d *Decoder) {
+	v, changed := f.DecMapIntUint64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntUint64V(v map[int]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntUint64V(v map[int]uint64, canChange bool,
 	d *Decoder) (_ map[int]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -30417,63 +27688,58 @@ func (_ fastpathT) DecMapIntUint64V(v map[int]uint64, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int
 	var mv uint64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int(dd.DecodeInt(intBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeUint(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntUintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int]uintptr)
-		v, changed := fastpathTV.DecMapIntUintptrV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]uintptr)
+		v, changed := fastpathTV.DecMapIntUintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int]uintptr)
-		fastpathTV.DecMapIntUintptrV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntUintptrV(rv2i(rv).(map[int]uintptr), false, d)
 	}
 }
-func (f fastpathT) DecMapIntUintptrX(vp *map[int]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntUintptrV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntUintptrX(vp *map[int]uintptr, d *Decoder) {
+	v, changed := f.DecMapIntUintptrV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntUintptrV(v map[int]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntUintptrV(v map[int]uintptr, canChange bool,
 	d *Decoder) (_ map[int]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -30481,63 +27747,58 @@ func (_ fastpathT) DecMapIntUintptrV(v map[int]uintptr, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int
 	var mv uintptr
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int(dd.DecodeInt(intBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uintptr(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntIntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int]int)
-		v, changed := fastpathTV.DecMapIntIntV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntIntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]int)
+		v, changed := fastpathTV.DecMapIntIntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int]int)
-		fastpathTV.DecMapIntIntV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntIntV(rv2i(rv).(map[int]int), false, d)
 	}
 }
-func (f fastpathT) DecMapIntIntX(vp *map[int]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntIntV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntIntX(vp *map[int]int, d *Decoder) {
+	v, changed := f.DecMapIntIntV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntIntV(v map[int]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntIntV(v map[int]int, canChange bool,
 	d *Decoder) (_ map[int]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -30545,63 +27806,58 @@ func (_ fastpathT) DecMapIntIntV(v map[int]int, checkNil bool, canChange bool,
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int
 	var mv int
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int(dd.DecodeInt(intBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int(dd.DecodeInt(intBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntInt8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int]int8)
-		v, changed := fastpathTV.DecMapIntInt8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntInt8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]int8)
+		v, changed := fastpathTV.DecMapIntInt8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int]int8)
-		fastpathTV.DecMapIntInt8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntInt8V(rv2i(rv).(map[int]int8), false, d)
 	}
 }
-func (f fastpathT) DecMapIntInt8X(vp *map[int]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntInt8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntInt8X(vp *map[int]int8, d *Decoder) {
+	v, changed := f.DecMapIntInt8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntInt8V(v map[int]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntInt8V(v map[int]int8, canChange bool,
 	d *Decoder) (_ map[int]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -30609,63 +27865,58 @@ func (_ fastpathT) DecMapIntInt8V(v map[int]int8, checkNil bool, canChange bool,
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int
 	var mv int8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int(dd.DecodeInt(intBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int8(dd.DecodeInt(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntInt16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int]int16)
-		v, changed := fastpathTV.DecMapIntInt16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntInt16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]int16)
+		v, changed := fastpathTV.DecMapIntInt16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int]int16)
-		fastpathTV.DecMapIntInt16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntInt16V(rv2i(rv).(map[int]int16), false, d)
 	}
 }
-func (f fastpathT) DecMapIntInt16X(vp *map[int]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntInt16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntInt16X(vp *map[int]int16, d *Decoder) {
+	v, changed := f.DecMapIntInt16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntInt16V(v map[int]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntInt16V(v map[int]int16, canChange bool,
 	d *Decoder) (_ map[int]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -30673,63 +27924,58 @@ func (_ fastpathT) DecMapIntInt16V(v map[int]int16, checkNil bool, canChange boo
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int
 	var mv int16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int(dd.DecodeInt(intBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int16(dd.DecodeInt(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntInt32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int]int32)
-		v, changed := fastpathTV.DecMapIntInt32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntInt32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]int32)
+		v, changed := fastpathTV.DecMapIntInt32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int]int32)
-		fastpathTV.DecMapIntInt32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntInt32V(rv2i(rv).(map[int]int32), false, d)
 	}
 }
-func (f fastpathT) DecMapIntInt32X(vp *map[int]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntInt32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntInt32X(vp *map[int]int32, d *Decoder) {
+	v, changed := f.DecMapIntInt32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntInt32V(v map[int]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntInt32V(v map[int]int32, canChange bool,
 	d *Decoder) (_ map[int]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -30737,63 +27983,58 @@ func (_ fastpathT) DecMapIntInt32V(v map[int]int32, checkNil bool, canChange boo
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int
 	var mv int32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int(dd.DecodeInt(intBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int32(dd.DecodeInt(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntInt64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int]int64)
-		v, changed := fastpathTV.DecMapIntInt64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntInt64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]int64)
+		v, changed := fastpathTV.DecMapIntInt64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int]int64)
-		fastpathTV.DecMapIntInt64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntInt64V(rv2i(rv).(map[int]int64), false, d)
 	}
 }
-func (f fastpathT) DecMapIntInt64X(vp *map[int]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntInt64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntInt64X(vp *map[int]int64, d *Decoder) {
+	v, changed := f.DecMapIntInt64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntInt64V(v map[int]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntInt64V(v map[int]int64, canChange bool,
 	d *Decoder) (_ map[int]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -30801,63 +28042,58 @@ func (_ fastpathT) DecMapIntInt64V(v map[int]int64, checkNil bool, canChange boo
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int
 	var mv int64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int(dd.DecodeInt(intBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeInt(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntFloat32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int]float32)
-		v, changed := fastpathTV.DecMapIntFloat32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntFloat32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]float32)
+		v, changed := fastpathTV.DecMapIntFloat32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int]float32)
-		fastpathTV.DecMapIntFloat32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntFloat32V(rv2i(rv).(map[int]float32), false, d)
 	}
 }
-func (f fastpathT) DecMapIntFloat32X(vp *map[int]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntFloat32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntFloat32X(vp *map[int]float32, d *Decoder) {
+	v, changed := f.DecMapIntFloat32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntFloat32V(v map[int]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntFloat32V(v map[int]float32, canChange bool,
 	d *Decoder) (_ map[int]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -30865,63 +28101,58 @@ func (_ fastpathT) DecMapIntFloat32V(v map[int]float32, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int
 	var mv float32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int(dd.DecodeInt(intBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = float32(dd.DecodeFloat(true))
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = float32(chkFloat32(dd.DecodeFloat64()))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntFloat64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int]float64)
-		v, changed := fastpathTV.DecMapIntFloat64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntFloat64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]float64)
+		v, changed := fastpathTV.DecMapIntFloat64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int]float64)
-		fastpathTV.DecMapIntFloat64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntFloat64V(rv2i(rv).(map[int]float64), false, d)
 	}
 }
-func (f fastpathT) DecMapIntFloat64X(vp *map[int]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntFloat64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntFloat64X(vp *map[int]float64, d *Decoder) {
+	v, changed := f.DecMapIntFloat64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntFloat64V(v map[int]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntFloat64V(v map[int]float64, canChange bool,
 	d *Decoder) (_ map[int]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -30929,63 +28160,58 @@ func (_ fastpathT) DecMapIntFloat64V(v map[int]float64, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int
 	var mv float64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int(dd.DecodeInt(intBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = dd.DecodeFloat(false)
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapIntBoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int]bool)
-		v, changed := fastpathTV.DecMapIntBoolV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapIntBoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]bool)
+		v, changed := fastpathTV.DecMapIntBoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int]bool)
-		fastpathTV.DecMapIntBoolV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapIntBoolV(rv2i(rv).(map[int]bool), false, d)
 	}
 }
-func (f fastpathT) DecMapIntBoolX(vp *map[int]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapIntBoolV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapIntBoolX(vp *map[int]bool, d *Decoder) {
+	v, changed := f.DecMapIntBoolV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapIntBoolV(v map[int]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapIntBoolV(v map[int]bool, canChange bool,
 	d *Decoder) (_ map[int]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -30993,63 +28219,58 @@ func (_ fastpathT) DecMapIntBoolV(v map[int]bool, checkNil bool, canChange bool,
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int
 	var mv bool
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int(dd.DecodeInt(intBitsize))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
+			}
+			continue
 		}
 		mv = dd.DecodeBool()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8IntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int8]interface{})
-		v, changed := fastpathTV.DecMapInt8IntfV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt8IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]interface{})
+		v, changed := fastpathTV.DecMapInt8IntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int8]interface{})
-		fastpathTV.DecMapInt8IntfV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt8IntfV(rv2i(rv).(map[int8]interface{}), false, d)
 	}
 }
-func (f fastpathT) DecMapInt8IntfX(vp *map[int8]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8IntfV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt8IntfX(vp *map[int8]interface{}, d *Decoder) {
+	v, changed := f.DecMapInt8IntfV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8IntfV(v map[int8]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8IntfV(v map[int8]interface{}, canChange bool,
 	d *Decoder) (_ map[int8]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
@@ -31057,22 +28278,29 @@ func (_ fastpathT) DecMapInt8IntfV(v map[int8]interface{}, checkNil bool, canCha
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk int8
 	var mv interface{}
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int8(dd.DecodeInt(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = nil
+			}
+			continue
 		}
 		if mapGet {
 			mv = v[mk]
@@ -31084,41 +28312,30 @@ func (_ fastpathT) DecMapInt8IntfV(v map[int8]interface{}, checkNil bool, canCha
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8StringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int8]string)
-		v, changed := fastpathTV.DecMapInt8StringV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt8StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]string)
+		v, changed := fastpathTV.DecMapInt8StringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int8]string)
-		fastpathTV.DecMapInt8StringV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt8StringV(rv2i(rv).(map[int8]string), false, d)
 	}
 }
-func (f fastpathT) DecMapInt8StringX(vp *map[int8]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8StringV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt8StringX(vp *map[int8]string, d *Decoder) {
+	v, changed := f.DecMapInt8StringV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8StringV(v map[int8]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8StringV(v map[int8]string, canChange bool,
 	d *Decoder) (_ map[int8]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
@@ -31126,63 +28343,58 @@ func (_ fastpathT) DecMapInt8StringV(v map[int8]string, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int8
 	var mv string
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int8(dd.DecodeInt(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
+			}
+			continue
 		}
 		mv = dd.DecodeString()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8UintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int8]uint)
-		v, changed := fastpathTV.DecMapInt8UintV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt8UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]uint)
+		v, changed := fastpathTV.DecMapInt8UintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int8]uint)
-		fastpathTV.DecMapInt8UintV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt8UintV(rv2i(rv).(map[int8]uint), false, d)
 	}
 }
-func (f fastpathT) DecMapInt8UintX(vp *map[int8]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8UintV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt8UintX(vp *map[int8]uint, d *Decoder) {
+	v, changed := f.DecMapInt8UintV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8UintV(v map[int8]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8UintV(v map[int8]uint, canChange bool,
 	d *Decoder) (_ map[int8]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -31190,63 +28402,58 @@ func (_ fastpathT) DecMapInt8UintV(v map[int8]uint, checkNil bool, canChange boo
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int8
 	var mv uint
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int8(dd.DecodeInt(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8Uint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int8]uint8)
-		v, changed := fastpathTV.DecMapInt8Uint8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt8Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]uint8)
+		v, changed := fastpathTV.DecMapInt8Uint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int8]uint8)
-		fastpathTV.DecMapInt8Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt8Uint8V(rv2i(rv).(map[int8]uint8), false, d)
 	}
 }
-func (f fastpathT) DecMapInt8Uint8X(vp *map[int8]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8Uint8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt8Uint8X(vp *map[int8]uint8, d *Decoder) {
+	v, changed := f.DecMapInt8Uint8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8Uint8V(v map[int8]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8Uint8V(v map[int8]uint8, canChange bool,
 	d *Decoder) (_ map[int8]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
@@ -31254,63 +28461,58 @@ func (_ fastpathT) DecMapInt8Uint8V(v map[int8]uint8, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int8
 	var mv uint8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int8(dd.DecodeInt(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint8(dd.DecodeUint(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8Uint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int8]uint16)
-		v, changed := fastpathTV.DecMapInt8Uint16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt8Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]uint16)
+		v, changed := fastpathTV.DecMapInt8Uint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int8]uint16)
-		fastpathTV.DecMapInt8Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt8Uint16V(rv2i(rv).(map[int8]uint16), false, d)
 	}
 }
-func (f fastpathT) DecMapInt8Uint16X(vp *map[int8]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8Uint16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt8Uint16X(vp *map[int8]uint16, d *Decoder) {
+	v, changed := f.DecMapInt8Uint16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8Uint16V(v map[int8]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8Uint16V(v map[int8]uint16, canChange bool,
 	d *Decoder) (_ map[int8]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
@@ -31318,63 +28520,58 @@ func (_ fastpathT) DecMapInt8Uint16V(v map[int8]uint16, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int8
 	var mv uint16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int8(dd.DecodeInt(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint16(dd.DecodeUint(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8Uint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int8]uint32)
-		v, changed := fastpathTV.DecMapInt8Uint32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt8Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]uint32)
+		v, changed := fastpathTV.DecMapInt8Uint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int8]uint32)
-		fastpathTV.DecMapInt8Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt8Uint32V(rv2i(rv).(map[int8]uint32), false, d)
 	}
 }
-func (f fastpathT) DecMapInt8Uint32X(vp *map[int8]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8Uint32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt8Uint32X(vp *map[int8]uint32, d *Decoder) {
+	v, changed := f.DecMapInt8Uint32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8Uint32V(v map[int8]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8Uint32V(v map[int8]uint32, canChange bool,
 	d *Decoder) (_ map[int8]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
@@ -31382,63 +28579,58 @@ func (_ fastpathT) DecMapInt8Uint32V(v map[int8]uint32, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int8
 	var mv uint32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int8(dd.DecodeInt(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint32(dd.DecodeUint(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8Uint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int8]uint64)
-		v, changed := fastpathTV.DecMapInt8Uint64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt8Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]uint64)
+		v, changed := fastpathTV.DecMapInt8Uint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int8]uint64)
-		fastpathTV.DecMapInt8Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt8Uint64V(rv2i(rv).(map[int8]uint64), false, d)
 	}
 }
-func (f fastpathT) DecMapInt8Uint64X(vp *map[int8]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8Uint64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt8Uint64X(vp *map[int8]uint64, d *Decoder) {
+	v, changed := f.DecMapInt8Uint64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8Uint64V(v map[int8]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8Uint64V(v map[int8]uint64, canChange bool,
 	d *Decoder) (_ map[int8]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -31446,63 +28638,58 @@ func (_ fastpathT) DecMapInt8Uint64V(v map[int8]uint64, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int8
 	var mv uint64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int8(dd.DecodeInt(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeUint(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8UintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int8]uintptr)
-		v, changed := fastpathTV.DecMapInt8UintptrV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt8UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]uintptr)
+		v, changed := fastpathTV.DecMapInt8UintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int8]uintptr)
-		fastpathTV.DecMapInt8UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt8UintptrV(rv2i(rv).(map[int8]uintptr), false, d)
 	}
 }
-func (f fastpathT) DecMapInt8UintptrX(vp *map[int8]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8UintptrV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt8UintptrX(vp *map[int8]uintptr, d *Decoder) {
+	v, changed := f.DecMapInt8UintptrV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8UintptrV(v map[int8]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8UintptrV(v map[int8]uintptr, canChange bool,
 	d *Decoder) (_ map[int8]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -31510,63 +28697,58 @@ func (_ fastpathT) DecMapInt8UintptrV(v map[int8]uintptr, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int8
 	var mv uintptr
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int8(dd.DecodeInt(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uintptr(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8IntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int8]int)
-		v, changed := fastpathTV.DecMapInt8IntV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt8IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]int)
+		v, changed := fastpathTV.DecMapInt8IntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int8]int)
-		fastpathTV.DecMapInt8IntV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt8IntV(rv2i(rv).(map[int8]int), false, d)
 	}
 }
-func (f fastpathT) DecMapInt8IntX(vp *map[int8]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8IntV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt8IntX(vp *map[int8]int, d *Decoder) {
+	v, changed := f.DecMapInt8IntV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8IntV(v map[int8]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8IntV(v map[int8]int, canChange bool,
 	d *Decoder) (_ map[int8]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -31574,63 +28756,58 @@ func (_ fastpathT) DecMapInt8IntV(v map[int8]int, checkNil bool, canChange bool,
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int8
 	var mv int
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int8(dd.DecodeInt(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int(dd.DecodeInt(intBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8Int8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int8]int8)
-		v, changed := fastpathTV.DecMapInt8Int8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt8Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]int8)
+		v, changed := fastpathTV.DecMapInt8Int8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int8]int8)
-		fastpathTV.DecMapInt8Int8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt8Int8V(rv2i(rv).(map[int8]int8), false, d)
 	}
 }
-func (f fastpathT) DecMapInt8Int8X(vp *map[int8]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8Int8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt8Int8X(vp *map[int8]int8, d *Decoder) {
+	v, changed := f.DecMapInt8Int8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8Int8V(v map[int8]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8Int8V(v map[int8]int8, canChange bool,
 	d *Decoder) (_ map[int8]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
@@ -31638,63 +28815,58 @@ func (_ fastpathT) DecMapInt8Int8V(v map[int8]int8, checkNil bool, canChange boo
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int8
 	var mv int8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int8(dd.DecodeInt(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int8(dd.DecodeInt(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8Int16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int8]int16)
-		v, changed := fastpathTV.DecMapInt8Int16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt8Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]int16)
+		v, changed := fastpathTV.DecMapInt8Int16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int8]int16)
-		fastpathTV.DecMapInt8Int16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt8Int16V(rv2i(rv).(map[int8]int16), false, d)
 	}
 }
-func (f fastpathT) DecMapInt8Int16X(vp *map[int8]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8Int16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt8Int16X(vp *map[int8]int16, d *Decoder) {
+	v, changed := f.DecMapInt8Int16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8Int16V(v map[int8]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8Int16V(v map[int8]int16, canChange bool,
 	d *Decoder) (_ map[int8]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
@@ -31702,63 +28874,58 @@ func (_ fastpathT) DecMapInt8Int16V(v map[int8]int16, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int8
 	var mv int16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int8(dd.DecodeInt(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int16(dd.DecodeInt(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8Int32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int8]int32)
-		v, changed := fastpathTV.DecMapInt8Int32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt8Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]int32)
+		v, changed := fastpathTV.DecMapInt8Int32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int8]int32)
-		fastpathTV.DecMapInt8Int32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt8Int32V(rv2i(rv).(map[int8]int32), false, d)
 	}
 }
-func (f fastpathT) DecMapInt8Int32X(vp *map[int8]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8Int32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt8Int32X(vp *map[int8]int32, d *Decoder) {
+	v, changed := f.DecMapInt8Int32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8Int32V(v map[int8]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8Int32V(v map[int8]int32, canChange bool,
 	d *Decoder) (_ map[int8]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
@@ -31766,63 +28933,58 @@ func (_ fastpathT) DecMapInt8Int32V(v map[int8]int32, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int8
 	var mv int32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int8(dd.DecodeInt(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int32(dd.DecodeInt(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8Int64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int8]int64)
-		v, changed := fastpathTV.DecMapInt8Int64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt8Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]int64)
+		v, changed := fastpathTV.DecMapInt8Int64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int8]int64)
-		fastpathTV.DecMapInt8Int64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt8Int64V(rv2i(rv).(map[int8]int64), false, d)
 	}
 }
-func (f fastpathT) DecMapInt8Int64X(vp *map[int8]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8Int64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt8Int64X(vp *map[int8]int64, d *Decoder) {
+	v, changed := f.DecMapInt8Int64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8Int64V(v map[int8]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8Int64V(v map[int8]int64, canChange bool,
 	d *Decoder) (_ map[int8]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -31830,63 +28992,58 @@ func (_ fastpathT) DecMapInt8Int64V(v map[int8]int64, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int8
 	var mv int64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int8(dd.DecodeInt(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeInt(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8Float32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int8]float32)
-		v, changed := fastpathTV.DecMapInt8Float32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt8Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]float32)
+		v, changed := fastpathTV.DecMapInt8Float32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int8]float32)
-		fastpathTV.DecMapInt8Float32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt8Float32V(rv2i(rv).(map[int8]float32), false, d)
 	}
 }
-func (f fastpathT) DecMapInt8Float32X(vp *map[int8]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8Float32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt8Float32X(vp *map[int8]float32, d *Decoder) {
+	v, changed := f.DecMapInt8Float32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8Float32V(v map[int8]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8Float32V(v map[int8]float32, canChange bool,
 	d *Decoder) (_ map[int8]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
@@ -31894,63 +29051,58 @@ func (_ fastpathT) DecMapInt8Float32V(v map[int8]float32, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int8
 	var mv float32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int8(dd.DecodeInt(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = float32(dd.DecodeFloat(true))
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = float32(chkFloat32(dd.DecodeFloat64()))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8Float64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int8]float64)
-		v, changed := fastpathTV.DecMapInt8Float64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt8Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]float64)
+		v, changed := fastpathTV.DecMapInt8Float64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int8]float64)
-		fastpathTV.DecMapInt8Float64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt8Float64V(rv2i(rv).(map[int8]float64), false, d)
 	}
 }
-func (f fastpathT) DecMapInt8Float64X(vp *map[int8]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8Float64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt8Float64X(vp *map[int8]float64, d *Decoder) {
+	v, changed := f.DecMapInt8Float64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8Float64V(v map[int8]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8Float64V(v map[int8]float64, canChange bool,
 	d *Decoder) (_ map[int8]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -31958,63 +29110,58 @@ func (_ fastpathT) DecMapInt8Float64V(v map[int8]float64, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int8
 	var mv float64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int8(dd.DecodeInt(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = dd.DecodeFloat(false)
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt8BoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int8]bool)
-		v, changed := fastpathTV.DecMapInt8BoolV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt8BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]bool)
+		v, changed := fastpathTV.DecMapInt8BoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int8]bool)
-		fastpathTV.DecMapInt8BoolV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt8BoolV(rv2i(rv).(map[int8]bool), false, d)
 	}
 }
-func (f fastpathT) DecMapInt8BoolX(vp *map[int8]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt8BoolV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt8BoolX(vp *map[int8]bool, d *Decoder) {
+	v, changed := f.DecMapInt8BoolV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt8BoolV(v map[int8]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt8BoolV(v map[int8]bool, canChange bool,
 	d *Decoder) (_ map[int8]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
@@ -32022,63 +29169,58 @@ func (_ fastpathT) DecMapInt8BoolV(v map[int8]bool, checkNil bool, canChange boo
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int8
 	var mv bool
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int8(dd.DecodeInt(8))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
+			}
+			continue
 		}
 		mv = dd.DecodeBool()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16IntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int16]interface{})
-		v, changed := fastpathTV.DecMapInt16IntfV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt16IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]interface{})
+		v, changed := fastpathTV.DecMapInt16IntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int16]interface{})
-		fastpathTV.DecMapInt16IntfV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt16IntfV(rv2i(rv).(map[int16]interface{}), false, d)
 	}
 }
-func (f fastpathT) DecMapInt16IntfX(vp *map[int16]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16IntfV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt16IntfX(vp *map[int16]interface{}, d *Decoder) {
+	v, changed := f.DecMapInt16IntfV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16IntfV(v map[int16]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16IntfV(v map[int16]interface{}, canChange bool,
 	d *Decoder) (_ map[int16]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
@@ -32086,22 +29228,29 @@ func (_ fastpathT) DecMapInt16IntfV(v map[int16]interface{}, checkNil bool, canC
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk int16
 	var mv interface{}
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int16(dd.DecodeInt(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = nil
+			}
+			continue
 		}
 		if mapGet {
 			mv = v[mk]
@@ -32113,41 +29262,30 @@ func (_ fastpathT) DecMapInt16IntfV(v map[int16]interface{}, checkNil bool, canC
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16StringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int16]string)
-		v, changed := fastpathTV.DecMapInt16StringV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt16StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]string)
+		v, changed := fastpathTV.DecMapInt16StringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int16]string)
-		fastpathTV.DecMapInt16StringV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt16StringV(rv2i(rv).(map[int16]string), false, d)
 	}
 }
-func (f fastpathT) DecMapInt16StringX(vp *map[int16]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16StringV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt16StringX(vp *map[int16]string, d *Decoder) {
+	v, changed := f.DecMapInt16StringV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16StringV(v map[int16]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16StringV(v map[int16]string, canChange bool,
 	d *Decoder) (_ map[int16]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
@@ -32155,63 +29293,58 @@ func (_ fastpathT) DecMapInt16StringV(v map[int16]string, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int16
 	var mv string
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int16(dd.DecodeInt(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
+			}
+			continue
 		}
 		mv = dd.DecodeString()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16UintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int16]uint)
-		v, changed := fastpathTV.DecMapInt16UintV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt16UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]uint)
+		v, changed := fastpathTV.DecMapInt16UintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int16]uint)
-		fastpathTV.DecMapInt16UintV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt16UintV(rv2i(rv).(map[int16]uint), false, d)
 	}
 }
-func (f fastpathT) DecMapInt16UintX(vp *map[int16]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16UintV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt16UintX(vp *map[int16]uint, d *Decoder) {
+	v, changed := f.DecMapInt16UintV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16UintV(v map[int16]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16UintV(v map[int16]uint, canChange bool,
 	d *Decoder) (_ map[int16]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -32219,63 +29352,58 @@ func (_ fastpathT) DecMapInt16UintV(v map[int16]uint, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int16
 	var mv uint
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int16(dd.DecodeInt(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16Uint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int16]uint8)
-		v, changed := fastpathTV.DecMapInt16Uint8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt16Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]uint8)
+		v, changed := fastpathTV.DecMapInt16Uint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int16]uint8)
-		fastpathTV.DecMapInt16Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt16Uint8V(rv2i(rv).(map[int16]uint8), false, d)
 	}
 }
-func (f fastpathT) DecMapInt16Uint8X(vp *map[int16]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16Uint8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt16Uint8X(vp *map[int16]uint8, d *Decoder) {
+	v, changed := f.DecMapInt16Uint8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16Uint8V(v map[int16]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16Uint8V(v map[int16]uint8, canChange bool,
 	d *Decoder) (_ map[int16]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
@@ -32283,63 +29411,58 @@ func (_ fastpathT) DecMapInt16Uint8V(v map[int16]uint8, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int16
 	var mv uint8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int16(dd.DecodeInt(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint8(dd.DecodeUint(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16Uint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int16]uint16)
-		v, changed := fastpathTV.DecMapInt16Uint16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt16Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]uint16)
+		v, changed := fastpathTV.DecMapInt16Uint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int16]uint16)
-		fastpathTV.DecMapInt16Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt16Uint16V(rv2i(rv).(map[int16]uint16), false, d)
 	}
 }
-func (f fastpathT) DecMapInt16Uint16X(vp *map[int16]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16Uint16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt16Uint16X(vp *map[int16]uint16, d *Decoder) {
+	v, changed := f.DecMapInt16Uint16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16Uint16V(v map[int16]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16Uint16V(v map[int16]uint16, canChange bool,
 	d *Decoder) (_ map[int16]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 4)
@@ -32347,63 +29470,58 @@ func (_ fastpathT) DecMapInt16Uint16V(v map[int16]uint16, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int16
 	var mv uint16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int16(dd.DecodeInt(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint16(dd.DecodeUint(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16Uint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int16]uint32)
-		v, changed := fastpathTV.DecMapInt16Uint32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt16Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]uint32)
+		v, changed := fastpathTV.DecMapInt16Uint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int16]uint32)
-		fastpathTV.DecMapInt16Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt16Uint32V(rv2i(rv).(map[int16]uint32), false, d)
 	}
 }
-func (f fastpathT) DecMapInt16Uint32X(vp *map[int16]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16Uint32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt16Uint32X(vp *map[int16]uint32, d *Decoder) {
+	v, changed := f.DecMapInt16Uint32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16Uint32V(v map[int16]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16Uint32V(v map[int16]uint32, canChange bool,
 	d *Decoder) (_ map[int16]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
@@ -32411,63 +29529,58 @@ func (_ fastpathT) DecMapInt16Uint32V(v map[int16]uint32, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int16
 	var mv uint32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int16(dd.DecodeInt(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint32(dd.DecodeUint(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16Uint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int16]uint64)
-		v, changed := fastpathTV.DecMapInt16Uint64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt16Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]uint64)
+		v, changed := fastpathTV.DecMapInt16Uint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int16]uint64)
-		fastpathTV.DecMapInt16Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt16Uint64V(rv2i(rv).(map[int16]uint64), false, d)
 	}
 }
-func (f fastpathT) DecMapInt16Uint64X(vp *map[int16]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16Uint64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt16Uint64X(vp *map[int16]uint64, d *Decoder) {
+	v, changed := f.DecMapInt16Uint64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16Uint64V(v map[int16]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16Uint64V(v map[int16]uint64, canChange bool,
 	d *Decoder) (_ map[int16]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -32475,63 +29588,58 @@ func (_ fastpathT) DecMapInt16Uint64V(v map[int16]uint64, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int16
 	var mv uint64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int16(dd.DecodeInt(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeUint(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16UintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int16]uintptr)
-		v, changed := fastpathTV.DecMapInt16UintptrV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt16UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]uintptr)
+		v, changed := fastpathTV.DecMapInt16UintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int16]uintptr)
-		fastpathTV.DecMapInt16UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt16UintptrV(rv2i(rv).(map[int16]uintptr), false, d)
 	}
 }
-func (f fastpathT) DecMapInt16UintptrX(vp *map[int16]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16UintptrV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt16UintptrX(vp *map[int16]uintptr, d *Decoder) {
+	v, changed := f.DecMapInt16UintptrV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16UintptrV(v map[int16]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16UintptrV(v map[int16]uintptr, canChange bool,
 	d *Decoder) (_ map[int16]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -32539,63 +29647,58 @@ func (_ fastpathT) DecMapInt16UintptrV(v map[int16]uintptr, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int16
 	var mv uintptr
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int16(dd.DecodeInt(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uintptr(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16IntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int16]int)
-		v, changed := fastpathTV.DecMapInt16IntV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt16IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]int)
+		v, changed := fastpathTV.DecMapInt16IntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int16]int)
-		fastpathTV.DecMapInt16IntV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt16IntV(rv2i(rv).(map[int16]int), false, d)
 	}
 }
-func (f fastpathT) DecMapInt16IntX(vp *map[int16]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16IntV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt16IntX(vp *map[int16]int, d *Decoder) {
+	v, changed := f.DecMapInt16IntV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16IntV(v map[int16]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16IntV(v map[int16]int, canChange bool,
 	d *Decoder) (_ map[int16]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -32603,63 +29706,58 @@ func (_ fastpathT) DecMapInt16IntV(v map[int16]int, checkNil bool, canChange boo
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int16
 	var mv int
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int16(dd.DecodeInt(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int(dd.DecodeInt(intBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16Int8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int16]int8)
-		v, changed := fastpathTV.DecMapInt16Int8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt16Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]int8)
+		v, changed := fastpathTV.DecMapInt16Int8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int16]int8)
-		fastpathTV.DecMapInt16Int8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt16Int8V(rv2i(rv).(map[int16]int8), false, d)
 	}
 }
-func (f fastpathT) DecMapInt16Int8X(vp *map[int16]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16Int8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt16Int8X(vp *map[int16]int8, d *Decoder) {
+	v, changed := f.DecMapInt16Int8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16Int8V(v map[int16]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16Int8V(v map[int16]int8, canChange bool,
 	d *Decoder) (_ map[int16]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
@@ -32667,63 +29765,58 @@ func (_ fastpathT) DecMapInt16Int8V(v map[int16]int8, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int16
 	var mv int8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int16(dd.DecodeInt(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int8(dd.DecodeInt(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16Int16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int16]int16)
-		v, changed := fastpathTV.DecMapInt16Int16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt16Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]int16)
+		v, changed := fastpathTV.DecMapInt16Int16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int16]int16)
-		fastpathTV.DecMapInt16Int16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt16Int16V(rv2i(rv).(map[int16]int16), false, d)
 	}
 }
-func (f fastpathT) DecMapInt16Int16X(vp *map[int16]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16Int16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt16Int16X(vp *map[int16]int16, d *Decoder) {
+	v, changed := f.DecMapInt16Int16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16Int16V(v map[int16]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16Int16V(v map[int16]int16, canChange bool,
 	d *Decoder) (_ map[int16]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 4)
@@ -32731,63 +29824,58 @@ func (_ fastpathT) DecMapInt16Int16V(v map[int16]int16, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int16
 	var mv int16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int16(dd.DecodeInt(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int16(dd.DecodeInt(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16Int32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int16]int32)
-		v, changed := fastpathTV.DecMapInt16Int32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt16Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]int32)
+		v, changed := fastpathTV.DecMapInt16Int32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int16]int32)
-		fastpathTV.DecMapInt16Int32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt16Int32V(rv2i(rv).(map[int16]int32), false, d)
 	}
 }
-func (f fastpathT) DecMapInt16Int32X(vp *map[int16]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16Int32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt16Int32X(vp *map[int16]int32, d *Decoder) {
+	v, changed := f.DecMapInt16Int32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16Int32V(v map[int16]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16Int32V(v map[int16]int32, canChange bool,
 	d *Decoder) (_ map[int16]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
@@ -32795,63 +29883,58 @@ func (_ fastpathT) DecMapInt16Int32V(v map[int16]int32, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int16
 	var mv int32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int16(dd.DecodeInt(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int32(dd.DecodeInt(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16Int64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int16]int64)
-		v, changed := fastpathTV.DecMapInt16Int64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt16Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]int64)
+		v, changed := fastpathTV.DecMapInt16Int64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int16]int64)
-		fastpathTV.DecMapInt16Int64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt16Int64V(rv2i(rv).(map[int16]int64), false, d)
 	}
 }
-func (f fastpathT) DecMapInt16Int64X(vp *map[int16]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16Int64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt16Int64X(vp *map[int16]int64, d *Decoder) {
+	v, changed := f.DecMapInt16Int64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16Int64V(v map[int16]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16Int64V(v map[int16]int64, canChange bool,
 	d *Decoder) (_ map[int16]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -32859,63 +29942,58 @@ func (_ fastpathT) DecMapInt16Int64V(v map[int16]int64, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int16
 	var mv int64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int16(dd.DecodeInt(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeInt(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16Float32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int16]float32)
-		v, changed := fastpathTV.DecMapInt16Float32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt16Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]float32)
+		v, changed := fastpathTV.DecMapInt16Float32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int16]float32)
-		fastpathTV.DecMapInt16Float32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt16Float32V(rv2i(rv).(map[int16]float32), false, d)
 	}
 }
-func (f fastpathT) DecMapInt16Float32X(vp *map[int16]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16Float32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt16Float32X(vp *map[int16]float32, d *Decoder) {
+	v, changed := f.DecMapInt16Float32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16Float32V(v map[int16]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16Float32V(v map[int16]float32, canChange bool,
 	d *Decoder) (_ map[int16]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
@@ -32923,63 +30001,58 @@ func (_ fastpathT) DecMapInt16Float32V(v map[int16]float32, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int16
 	var mv float32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int16(dd.DecodeInt(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = float32(dd.DecodeFloat(true))
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = float32(chkFloat32(dd.DecodeFloat64()))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16Float64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int16]float64)
-		v, changed := fastpathTV.DecMapInt16Float64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt16Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]float64)
+		v, changed := fastpathTV.DecMapInt16Float64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int16]float64)
-		fastpathTV.DecMapInt16Float64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt16Float64V(rv2i(rv).(map[int16]float64), false, d)
 	}
 }
-func (f fastpathT) DecMapInt16Float64X(vp *map[int16]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16Float64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt16Float64X(vp *map[int16]float64, d *Decoder) {
+	v, changed := f.DecMapInt16Float64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16Float64V(v map[int16]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16Float64V(v map[int16]float64, canChange bool,
 	d *Decoder) (_ map[int16]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -32987,63 +30060,58 @@ func (_ fastpathT) DecMapInt16Float64V(v map[int16]float64, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int16
 	var mv float64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int16(dd.DecodeInt(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = dd.DecodeFloat(false)
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt16BoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int16]bool)
-		v, changed := fastpathTV.DecMapInt16BoolV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt16BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]bool)
+		v, changed := fastpathTV.DecMapInt16BoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int16]bool)
-		fastpathTV.DecMapInt16BoolV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt16BoolV(rv2i(rv).(map[int16]bool), false, d)
 	}
 }
-func (f fastpathT) DecMapInt16BoolX(vp *map[int16]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt16BoolV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt16BoolX(vp *map[int16]bool, d *Decoder) {
+	v, changed := f.DecMapInt16BoolV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt16BoolV(v map[int16]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt16BoolV(v map[int16]bool, canChange bool,
 	d *Decoder) (_ map[int16]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
@@ -33051,63 +30119,58 @@ func (_ fastpathT) DecMapInt16BoolV(v map[int16]bool, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int16
 	var mv bool
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int16(dd.DecodeInt(16))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
+			}
+			continue
 		}
 		mv = dd.DecodeBool()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32IntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int32]interface{})
-		v, changed := fastpathTV.DecMapInt32IntfV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt32IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]interface{})
+		v, changed := fastpathTV.DecMapInt32IntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int32]interface{})
-		fastpathTV.DecMapInt32IntfV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt32IntfV(rv2i(rv).(map[int32]interface{}), false, d)
 	}
 }
-func (f fastpathT) DecMapInt32IntfX(vp *map[int32]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32IntfV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt32IntfX(vp *map[int32]interface{}, d *Decoder) {
+	v, changed := f.DecMapInt32IntfV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32IntfV(v map[int32]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32IntfV(v map[int32]interface{}, canChange bool,
 	d *Decoder) (_ map[int32]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
@@ -33115,22 +30178,29 @@ func (_ fastpathT) DecMapInt32IntfV(v map[int32]interface{}, checkNil bool, canC
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk int32
 	var mv interface{}
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int32(dd.DecodeInt(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = nil
+			}
+			continue
 		}
 		if mapGet {
 			mv = v[mk]
@@ -33142,41 +30212,30 @@ func (_ fastpathT) DecMapInt32IntfV(v map[int32]interface{}, checkNil bool, canC
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32StringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int32]string)
-		v, changed := fastpathTV.DecMapInt32StringV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt32StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]string)
+		v, changed := fastpathTV.DecMapInt32StringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int32]string)
-		fastpathTV.DecMapInt32StringV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt32StringV(rv2i(rv).(map[int32]string), false, d)
 	}
 }
-func (f fastpathT) DecMapInt32StringX(vp *map[int32]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32StringV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt32StringX(vp *map[int32]string, d *Decoder) {
+	v, changed := f.DecMapInt32StringV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32StringV(v map[int32]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32StringV(v map[int32]string, canChange bool,
 	d *Decoder) (_ map[int32]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
@@ -33184,63 +30243,58 @@ func (_ fastpathT) DecMapInt32StringV(v map[int32]string, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int32
 	var mv string
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int32(dd.DecodeInt(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
+			}
+			continue
 		}
 		mv = dd.DecodeString()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32UintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int32]uint)
-		v, changed := fastpathTV.DecMapInt32UintV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt32UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]uint)
+		v, changed := fastpathTV.DecMapInt32UintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int32]uint)
-		fastpathTV.DecMapInt32UintV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt32UintV(rv2i(rv).(map[int32]uint), false, d)
 	}
 }
-func (f fastpathT) DecMapInt32UintX(vp *map[int32]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32UintV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt32UintX(vp *map[int32]uint, d *Decoder) {
+	v, changed := f.DecMapInt32UintV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32UintV(v map[int32]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32UintV(v map[int32]uint, canChange bool,
 	d *Decoder) (_ map[int32]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -33248,63 +30302,58 @@ func (_ fastpathT) DecMapInt32UintV(v map[int32]uint, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int32
 	var mv uint
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int32(dd.DecodeInt(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32Uint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int32]uint8)
-		v, changed := fastpathTV.DecMapInt32Uint8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt32Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]uint8)
+		v, changed := fastpathTV.DecMapInt32Uint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int32]uint8)
-		fastpathTV.DecMapInt32Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt32Uint8V(rv2i(rv).(map[int32]uint8), false, d)
 	}
 }
-func (f fastpathT) DecMapInt32Uint8X(vp *map[int32]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32Uint8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt32Uint8X(vp *map[int32]uint8, d *Decoder) {
+	v, changed := f.DecMapInt32Uint8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32Uint8V(v map[int32]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32Uint8V(v map[int32]uint8, canChange bool,
 	d *Decoder) (_ map[int32]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
@@ -33312,63 +30361,58 @@ func (_ fastpathT) DecMapInt32Uint8V(v map[int32]uint8, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int32
 	var mv uint8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int32(dd.DecodeInt(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint8(dd.DecodeUint(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32Uint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int32]uint16)
-		v, changed := fastpathTV.DecMapInt32Uint16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt32Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]uint16)
+		v, changed := fastpathTV.DecMapInt32Uint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int32]uint16)
-		fastpathTV.DecMapInt32Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt32Uint16V(rv2i(rv).(map[int32]uint16), false, d)
 	}
 }
-func (f fastpathT) DecMapInt32Uint16X(vp *map[int32]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32Uint16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt32Uint16X(vp *map[int32]uint16, d *Decoder) {
+	v, changed := f.DecMapInt32Uint16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32Uint16V(v map[int32]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32Uint16V(v map[int32]uint16, canChange bool,
 	d *Decoder) (_ map[int32]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
@@ -33376,63 +30420,58 @@ func (_ fastpathT) DecMapInt32Uint16V(v map[int32]uint16, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int32
 	var mv uint16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int32(dd.DecodeInt(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint16(dd.DecodeUint(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32Uint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int32]uint32)
-		v, changed := fastpathTV.DecMapInt32Uint32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt32Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]uint32)
+		v, changed := fastpathTV.DecMapInt32Uint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int32]uint32)
-		fastpathTV.DecMapInt32Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt32Uint32V(rv2i(rv).(map[int32]uint32), false, d)
 	}
 }
-func (f fastpathT) DecMapInt32Uint32X(vp *map[int32]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32Uint32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt32Uint32X(vp *map[int32]uint32, d *Decoder) {
+	v, changed := f.DecMapInt32Uint32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32Uint32V(v map[int32]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32Uint32V(v map[int32]uint32, canChange bool,
 	d *Decoder) (_ map[int32]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
@@ -33440,63 +30479,58 @@ func (_ fastpathT) DecMapInt32Uint32V(v map[int32]uint32, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int32
 	var mv uint32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int32(dd.DecodeInt(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint32(dd.DecodeUint(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32Uint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int32]uint64)
-		v, changed := fastpathTV.DecMapInt32Uint64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt32Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]uint64)
+		v, changed := fastpathTV.DecMapInt32Uint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int32]uint64)
-		fastpathTV.DecMapInt32Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt32Uint64V(rv2i(rv).(map[int32]uint64), false, d)
 	}
 }
-func (f fastpathT) DecMapInt32Uint64X(vp *map[int32]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32Uint64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt32Uint64X(vp *map[int32]uint64, d *Decoder) {
+	v, changed := f.DecMapInt32Uint64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32Uint64V(v map[int32]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32Uint64V(v map[int32]uint64, canChange bool,
 	d *Decoder) (_ map[int32]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -33504,63 +30538,58 @@ func (_ fastpathT) DecMapInt32Uint64V(v map[int32]uint64, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int32
 	var mv uint64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int32(dd.DecodeInt(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeUint(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32UintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int32]uintptr)
-		v, changed := fastpathTV.DecMapInt32UintptrV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt32UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]uintptr)
+		v, changed := fastpathTV.DecMapInt32UintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int32]uintptr)
-		fastpathTV.DecMapInt32UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt32UintptrV(rv2i(rv).(map[int32]uintptr), false, d)
 	}
 }
-func (f fastpathT) DecMapInt32UintptrX(vp *map[int32]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32UintptrV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt32UintptrX(vp *map[int32]uintptr, d *Decoder) {
+	v, changed := f.DecMapInt32UintptrV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32UintptrV(v map[int32]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32UintptrV(v map[int32]uintptr, canChange bool,
 	d *Decoder) (_ map[int32]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -33568,63 +30597,58 @@ func (_ fastpathT) DecMapInt32UintptrV(v map[int32]uintptr, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int32
 	var mv uintptr
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int32(dd.DecodeInt(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uintptr(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32IntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int32]int)
-		v, changed := fastpathTV.DecMapInt32IntV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt32IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]int)
+		v, changed := fastpathTV.DecMapInt32IntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int32]int)
-		fastpathTV.DecMapInt32IntV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt32IntV(rv2i(rv).(map[int32]int), false, d)
 	}
 }
-func (f fastpathT) DecMapInt32IntX(vp *map[int32]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32IntV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt32IntX(vp *map[int32]int, d *Decoder) {
+	v, changed := f.DecMapInt32IntV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32IntV(v map[int32]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32IntV(v map[int32]int, canChange bool,
 	d *Decoder) (_ map[int32]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -33632,63 +30656,58 @@ func (_ fastpathT) DecMapInt32IntV(v map[int32]int, checkNil bool, canChange boo
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int32
 	var mv int
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int32(dd.DecodeInt(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int(dd.DecodeInt(intBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32Int8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int32]int8)
-		v, changed := fastpathTV.DecMapInt32Int8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt32Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]int8)
+		v, changed := fastpathTV.DecMapInt32Int8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int32]int8)
-		fastpathTV.DecMapInt32Int8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt32Int8V(rv2i(rv).(map[int32]int8), false, d)
 	}
 }
-func (f fastpathT) DecMapInt32Int8X(vp *map[int32]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32Int8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt32Int8X(vp *map[int32]int8, d *Decoder) {
+	v, changed := f.DecMapInt32Int8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32Int8V(v map[int32]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32Int8V(v map[int32]int8, canChange bool,
 	d *Decoder) (_ map[int32]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
@@ -33696,63 +30715,58 @@ func (_ fastpathT) DecMapInt32Int8V(v map[int32]int8, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int32
 	var mv int8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int32(dd.DecodeInt(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int8(dd.DecodeInt(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32Int16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int32]int16)
-		v, changed := fastpathTV.DecMapInt32Int16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt32Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]int16)
+		v, changed := fastpathTV.DecMapInt32Int16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int32]int16)
-		fastpathTV.DecMapInt32Int16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt32Int16V(rv2i(rv).(map[int32]int16), false, d)
 	}
 }
-func (f fastpathT) DecMapInt32Int16X(vp *map[int32]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32Int16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt32Int16X(vp *map[int32]int16, d *Decoder) {
+	v, changed := f.DecMapInt32Int16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32Int16V(v map[int32]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32Int16V(v map[int32]int16, canChange bool,
 	d *Decoder) (_ map[int32]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
@@ -33760,63 +30774,58 @@ func (_ fastpathT) DecMapInt32Int16V(v map[int32]int16, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int32
 	var mv int16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int32(dd.DecodeInt(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int16(dd.DecodeInt(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32Int32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int32]int32)
-		v, changed := fastpathTV.DecMapInt32Int32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt32Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]int32)
+		v, changed := fastpathTV.DecMapInt32Int32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int32]int32)
-		fastpathTV.DecMapInt32Int32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt32Int32V(rv2i(rv).(map[int32]int32), false, d)
 	}
 }
-func (f fastpathT) DecMapInt32Int32X(vp *map[int32]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32Int32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt32Int32X(vp *map[int32]int32, d *Decoder) {
+	v, changed := f.DecMapInt32Int32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32Int32V(v map[int32]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32Int32V(v map[int32]int32, canChange bool,
 	d *Decoder) (_ map[int32]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
@@ -33824,63 +30833,58 @@ func (_ fastpathT) DecMapInt32Int32V(v map[int32]int32, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int32
 	var mv int32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int32(dd.DecodeInt(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int32(dd.DecodeInt(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32Int64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int32]int64)
-		v, changed := fastpathTV.DecMapInt32Int64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt32Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]int64)
+		v, changed := fastpathTV.DecMapInt32Int64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int32]int64)
-		fastpathTV.DecMapInt32Int64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt32Int64V(rv2i(rv).(map[int32]int64), false, d)
 	}
 }
-func (f fastpathT) DecMapInt32Int64X(vp *map[int32]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32Int64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt32Int64X(vp *map[int32]int64, d *Decoder) {
+	v, changed := f.DecMapInt32Int64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32Int64V(v map[int32]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32Int64V(v map[int32]int64, canChange bool,
 	d *Decoder) (_ map[int32]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -33888,63 +30892,58 @@ func (_ fastpathT) DecMapInt32Int64V(v map[int32]int64, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int32
 	var mv int64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int32(dd.DecodeInt(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeInt(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32Float32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int32]float32)
-		v, changed := fastpathTV.DecMapInt32Float32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt32Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]float32)
+		v, changed := fastpathTV.DecMapInt32Float32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int32]float32)
-		fastpathTV.DecMapInt32Float32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt32Float32V(rv2i(rv).(map[int32]float32), false, d)
 	}
 }
-func (f fastpathT) DecMapInt32Float32X(vp *map[int32]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32Float32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt32Float32X(vp *map[int32]float32, d *Decoder) {
+	v, changed := f.DecMapInt32Float32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32Float32V(v map[int32]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32Float32V(v map[int32]float32, canChange bool,
 	d *Decoder) (_ map[int32]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
@@ -33952,63 +30951,58 @@ func (_ fastpathT) DecMapInt32Float32V(v map[int32]float32, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int32
 	var mv float32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int32(dd.DecodeInt(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = float32(dd.DecodeFloat(true))
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = float32(chkFloat32(dd.DecodeFloat64()))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32Float64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int32]float64)
-		v, changed := fastpathTV.DecMapInt32Float64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt32Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]float64)
+		v, changed := fastpathTV.DecMapInt32Float64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int32]float64)
-		fastpathTV.DecMapInt32Float64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt32Float64V(rv2i(rv).(map[int32]float64), false, d)
 	}
 }
-func (f fastpathT) DecMapInt32Float64X(vp *map[int32]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32Float64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt32Float64X(vp *map[int32]float64, d *Decoder) {
+	v, changed := f.DecMapInt32Float64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32Float64V(v map[int32]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32Float64V(v map[int32]float64, canChange bool,
 	d *Decoder) (_ map[int32]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -34016,63 +31010,58 @@ func (_ fastpathT) DecMapInt32Float64V(v map[int32]float64, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int32
 	var mv float64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int32(dd.DecodeInt(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = dd.DecodeFloat(false)
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt32BoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int32]bool)
-		v, changed := fastpathTV.DecMapInt32BoolV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt32BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]bool)
+		v, changed := fastpathTV.DecMapInt32BoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int32]bool)
-		fastpathTV.DecMapInt32BoolV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt32BoolV(rv2i(rv).(map[int32]bool), false, d)
 	}
 }
-func (f fastpathT) DecMapInt32BoolX(vp *map[int32]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt32BoolV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt32BoolX(vp *map[int32]bool, d *Decoder) {
+	v, changed := f.DecMapInt32BoolV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt32BoolV(v map[int32]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt32BoolV(v map[int32]bool, canChange bool,
 	d *Decoder) (_ map[int32]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
@@ -34080,63 +31069,58 @@ func (_ fastpathT) DecMapInt32BoolV(v map[int32]bool, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int32
 	var mv bool
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = int32(dd.DecodeInt(32))
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
+			}
+			continue
 		}
 		mv = dd.DecodeBool()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64IntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int64]interface{})
-		v, changed := fastpathTV.DecMapInt64IntfV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt64IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]interface{})
+		v, changed := fastpathTV.DecMapInt64IntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int64]interface{})
-		fastpathTV.DecMapInt64IntfV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt64IntfV(rv2i(rv).(map[int64]interface{}), false, d)
 	}
 }
-func (f fastpathT) DecMapInt64IntfX(vp *map[int64]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64IntfV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt64IntfX(vp *map[int64]interface{}, d *Decoder) {
+	v, changed := f.DecMapInt64IntfV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64IntfV(v map[int64]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64IntfV(v map[int64]interface{}, canChange bool,
 	d *Decoder) (_ map[int64]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -34144,22 +31128,29 @@ func (_ fastpathT) DecMapInt64IntfV(v map[int64]interface{}, checkNil bool, canC
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk int64
 	var mv interface{}
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeInt(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = nil
+			}
+			continue
 		}
 		if mapGet {
 			mv = v[mk]
@@ -34171,41 +31162,30 @@ func (_ fastpathT) DecMapInt64IntfV(v map[int64]interface{}, checkNil bool, canC
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64StringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int64]string)
-		v, changed := fastpathTV.DecMapInt64StringV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt64StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]string)
+		v, changed := fastpathTV.DecMapInt64StringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int64]string)
-		fastpathTV.DecMapInt64StringV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt64StringV(rv2i(rv).(map[int64]string), false, d)
 	}
 }
-func (f fastpathT) DecMapInt64StringX(vp *map[int64]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64StringV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt64StringX(vp *map[int64]string, d *Decoder) {
+	v, changed := f.DecMapInt64StringV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64StringV(v map[int64]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64StringV(v map[int64]string, canChange bool,
 	d *Decoder) (_ map[int64]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
@@ -34213,63 +31193,58 @@ func (_ fastpathT) DecMapInt64StringV(v map[int64]string, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int64
 	var mv string
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeInt(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
+			}
+			continue
 		}
 		mv = dd.DecodeString()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64UintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int64]uint)
-		v, changed := fastpathTV.DecMapInt64UintV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt64UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]uint)
+		v, changed := fastpathTV.DecMapInt64UintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int64]uint)
-		fastpathTV.DecMapInt64UintV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt64UintV(rv2i(rv).(map[int64]uint), false, d)
 	}
 }
-func (f fastpathT) DecMapInt64UintX(vp *map[int64]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64UintV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt64UintX(vp *map[int64]uint, d *Decoder) {
+	v, changed := f.DecMapInt64UintV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64UintV(v map[int64]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64UintV(v map[int64]uint, canChange bool,
 	d *Decoder) (_ map[int64]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -34277,63 +31252,58 @@ func (_ fastpathT) DecMapInt64UintV(v map[int64]uint, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int64
 	var mv uint
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeInt(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64Uint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int64]uint8)
-		v, changed := fastpathTV.DecMapInt64Uint8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt64Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]uint8)
+		v, changed := fastpathTV.DecMapInt64Uint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int64]uint8)
-		fastpathTV.DecMapInt64Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt64Uint8V(rv2i(rv).(map[int64]uint8), false, d)
 	}
 }
-func (f fastpathT) DecMapInt64Uint8X(vp *map[int64]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64Uint8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt64Uint8X(vp *map[int64]uint8, d *Decoder) {
+	v, changed := f.DecMapInt64Uint8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64Uint8V(v map[int64]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64Uint8V(v map[int64]uint8, canChange bool,
 	d *Decoder) (_ map[int64]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -34341,63 +31311,58 @@ func (_ fastpathT) DecMapInt64Uint8V(v map[int64]uint8, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int64
 	var mv uint8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeInt(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint8(dd.DecodeUint(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64Uint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int64]uint16)
-		v, changed := fastpathTV.DecMapInt64Uint16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt64Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]uint16)
+		v, changed := fastpathTV.DecMapInt64Uint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int64]uint16)
-		fastpathTV.DecMapInt64Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt64Uint16V(rv2i(rv).(map[int64]uint16), false, d)
 	}
 }
-func (f fastpathT) DecMapInt64Uint16X(vp *map[int64]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64Uint16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt64Uint16X(vp *map[int64]uint16, d *Decoder) {
+	v, changed := f.DecMapInt64Uint16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64Uint16V(v map[int64]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64Uint16V(v map[int64]uint16, canChange bool,
 	d *Decoder) (_ map[int64]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -34405,63 +31370,58 @@ func (_ fastpathT) DecMapInt64Uint16V(v map[int64]uint16, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int64
 	var mv uint16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeInt(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint16(dd.DecodeUint(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64Uint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int64]uint32)
-		v, changed := fastpathTV.DecMapInt64Uint32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt64Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]uint32)
+		v, changed := fastpathTV.DecMapInt64Uint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int64]uint32)
-		fastpathTV.DecMapInt64Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt64Uint32V(rv2i(rv).(map[int64]uint32), false, d)
 	}
 }
-func (f fastpathT) DecMapInt64Uint32X(vp *map[int64]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64Uint32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt64Uint32X(vp *map[int64]uint32, d *Decoder) {
+	v, changed := f.DecMapInt64Uint32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64Uint32V(v map[int64]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64Uint32V(v map[int64]uint32, canChange bool,
 	d *Decoder) (_ map[int64]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -34469,63 +31429,58 @@ func (_ fastpathT) DecMapInt64Uint32V(v map[int64]uint32, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int64
 	var mv uint32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeInt(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint32(dd.DecodeUint(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64Uint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int64]uint64)
-		v, changed := fastpathTV.DecMapInt64Uint64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt64Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]uint64)
+		v, changed := fastpathTV.DecMapInt64Uint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int64]uint64)
-		fastpathTV.DecMapInt64Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt64Uint64V(rv2i(rv).(map[int64]uint64), false, d)
 	}
 }
-func (f fastpathT) DecMapInt64Uint64X(vp *map[int64]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64Uint64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt64Uint64X(vp *map[int64]uint64, d *Decoder) {
+	v, changed := f.DecMapInt64Uint64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64Uint64V(v map[int64]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64Uint64V(v map[int64]uint64, canChange bool,
 	d *Decoder) (_ map[int64]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -34533,63 +31488,58 @@ func (_ fastpathT) DecMapInt64Uint64V(v map[int64]uint64, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int64
 	var mv uint64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeInt(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeUint(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64UintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int64]uintptr)
-		v, changed := fastpathTV.DecMapInt64UintptrV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt64UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]uintptr)
+		v, changed := fastpathTV.DecMapInt64UintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int64]uintptr)
-		fastpathTV.DecMapInt64UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt64UintptrV(rv2i(rv).(map[int64]uintptr), false, d)
 	}
 }
-func (f fastpathT) DecMapInt64UintptrX(vp *map[int64]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64UintptrV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt64UintptrX(vp *map[int64]uintptr, d *Decoder) {
+	v, changed := f.DecMapInt64UintptrV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64UintptrV(v map[int64]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64UintptrV(v map[int64]uintptr, canChange bool,
 	d *Decoder) (_ map[int64]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -34597,63 +31547,58 @@ func (_ fastpathT) DecMapInt64UintptrV(v map[int64]uintptr, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int64
 	var mv uintptr
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeInt(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uintptr(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64IntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int64]int)
-		v, changed := fastpathTV.DecMapInt64IntV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt64IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]int)
+		v, changed := fastpathTV.DecMapInt64IntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int64]int)
-		fastpathTV.DecMapInt64IntV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt64IntV(rv2i(rv).(map[int64]int), false, d)
 	}
 }
-func (f fastpathT) DecMapInt64IntX(vp *map[int64]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64IntV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt64IntX(vp *map[int64]int, d *Decoder) {
+	v, changed := f.DecMapInt64IntV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64IntV(v map[int64]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64IntV(v map[int64]int, canChange bool,
 	d *Decoder) (_ map[int64]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -34661,63 +31606,58 @@ func (_ fastpathT) DecMapInt64IntV(v map[int64]int, checkNil bool, canChange boo
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int64
 	var mv int
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeInt(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int(dd.DecodeInt(intBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64Int8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int64]int8)
-		v, changed := fastpathTV.DecMapInt64Int8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt64Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]int8)
+		v, changed := fastpathTV.DecMapInt64Int8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int64]int8)
-		fastpathTV.DecMapInt64Int8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt64Int8V(rv2i(rv).(map[int64]int8), false, d)
 	}
 }
-func (f fastpathT) DecMapInt64Int8X(vp *map[int64]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64Int8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt64Int8X(vp *map[int64]int8, d *Decoder) {
+	v, changed := f.DecMapInt64Int8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64Int8V(v map[int64]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64Int8V(v map[int64]int8, canChange bool,
 	d *Decoder) (_ map[int64]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -34725,63 +31665,58 @@ func (_ fastpathT) DecMapInt64Int8V(v map[int64]int8, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int64
 	var mv int8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeInt(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int8(dd.DecodeInt(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64Int16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int64]int16)
-		v, changed := fastpathTV.DecMapInt64Int16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt64Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]int16)
+		v, changed := fastpathTV.DecMapInt64Int16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int64]int16)
-		fastpathTV.DecMapInt64Int16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt64Int16V(rv2i(rv).(map[int64]int16), false, d)
 	}
 }
-func (f fastpathT) DecMapInt64Int16X(vp *map[int64]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64Int16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt64Int16X(vp *map[int64]int16, d *Decoder) {
+	v, changed := f.DecMapInt64Int16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64Int16V(v map[int64]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64Int16V(v map[int64]int16, canChange bool,
 	d *Decoder) (_ map[int64]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
@@ -34789,63 +31724,58 @@ func (_ fastpathT) DecMapInt64Int16V(v map[int64]int16, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int64
 	var mv int16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeInt(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int16(dd.DecodeInt(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64Int32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int64]int32)
-		v, changed := fastpathTV.DecMapInt64Int32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt64Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]int32)
+		v, changed := fastpathTV.DecMapInt64Int32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int64]int32)
-		fastpathTV.DecMapInt64Int32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt64Int32V(rv2i(rv).(map[int64]int32), false, d)
 	}
 }
-func (f fastpathT) DecMapInt64Int32X(vp *map[int64]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64Int32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt64Int32X(vp *map[int64]int32, d *Decoder) {
+	v, changed := f.DecMapInt64Int32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64Int32V(v map[int64]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64Int32V(v map[int64]int32, canChange bool,
 	d *Decoder) (_ map[int64]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -34853,63 +31783,58 @@ func (_ fastpathT) DecMapInt64Int32V(v map[int64]int32, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int64
 	var mv int32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeInt(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int32(dd.DecodeInt(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64Int64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int64]int64)
-		v, changed := fastpathTV.DecMapInt64Int64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt64Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]int64)
+		v, changed := fastpathTV.DecMapInt64Int64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int64]int64)
-		fastpathTV.DecMapInt64Int64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt64Int64V(rv2i(rv).(map[int64]int64), false, d)
 	}
 }
-func (f fastpathT) DecMapInt64Int64X(vp *map[int64]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64Int64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt64Int64X(vp *map[int64]int64, d *Decoder) {
+	v, changed := f.DecMapInt64Int64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64Int64V(v map[int64]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64Int64V(v map[int64]int64, canChange bool,
 	d *Decoder) (_ map[int64]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -34917,63 +31842,58 @@ func (_ fastpathT) DecMapInt64Int64V(v map[int64]int64, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int64
 	var mv int64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeInt(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeInt(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64Float32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int64]float32)
-		v, changed := fastpathTV.DecMapInt64Float32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt64Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]float32)
+		v, changed := fastpathTV.DecMapInt64Float32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int64]float32)
-		fastpathTV.DecMapInt64Float32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt64Float32V(rv2i(rv).(map[int64]float32), false, d)
 	}
 }
-func (f fastpathT) DecMapInt64Float32X(vp *map[int64]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64Float32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt64Float32X(vp *map[int64]float32, d *Decoder) {
+	v, changed := f.DecMapInt64Float32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64Float32V(v map[int64]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64Float32V(v map[int64]float32, canChange bool,
 	d *Decoder) (_ map[int64]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
@@ -34981,63 +31901,58 @@ func (_ fastpathT) DecMapInt64Float32V(v map[int64]float32, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int64
 	var mv float32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeInt(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = float32(dd.DecodeFloat(true))
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = float32(chkFloat32(dd.DecodeFloat64()))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64Float64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int64]float64)
-		v, changed := fastpathTV.DecMapInt64Float64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt64Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]float64)
+		v, changed := fastpathTV.DecMapInt64Float64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int64]float64)
-		fastpathTV.DecMapInt64Float64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt64Float64V(rv2i(rv).(map[int64]float64), false, d)
 	}
 }
-func (f fastpathT) DecMapInt64Float64X(vp *map[int64]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64Float64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt64Float64X(vp *map[int64]float64, d *Decoder) {
+	v, changed := f.DecMapInt64Float64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64Float64V(v map[int64]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64Float64V(v map[int64]float64, canChange bool,
 	d *Decoder) (_ map[int64]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
@@ -35045,63 +31960,58 @@ func (_ fastpathT) DecMapInt64Float64V(v map[int64]float64, checkNil bool, canCh
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int64
 	var mv float64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeInt(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = dd.DecodeFloat(false)
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapInt64BoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[int64]bool)
-		v, changed := fastpathTV.DecMapInt64BoolV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapInt64BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]bool)
+		v, changed := fastpathTV.DecMapInt64BoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[int64]bool)
-		fastpathTV.DecMapInt64BoolV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapInt64BoolV(rv2i(rv).(map[int64]bool), false, d)
 	}
 }
-func (f fastpathT) DecMapInt64BoolX(vp *map[int64]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapInt64BoolV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapInt64BoolX(vp *map[int64]bool, d *Decoder) {
+	v, changed := f.DecMapInt64BoolV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapInt64BoolV(v map[int64]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapInt64BoolV(v map[int64]bool, canChange bool,
 	d *Decoder) (_ map[int64]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -35109,63 +32019,58 @@ func (_ fastpathT) DecMapInt64BoolV(v map[int64]bool, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk int64
 	var mv bool
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeInt(64)
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
+			}
+			continue
 		}
 		mv = dd.DecodeBool()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolIntfR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[bool]interface{})
-		v, changed := fastpathTV.DecMapBoolIntfV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapBoolIntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]interface{})
+		v, changed := fastpathTV.DecMapBoolIntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[bool]interface{})
-		fastpathTV.DecMapBoolIntfV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapBoolIntfV(rv2i(rv).(map[bool]interface{}), false, d)
 	}
 }
-func (f fastpathT) DecMapBoolIntfX(vp *map[bool]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolIntfV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapBoolIntfX(vp *map[bool]interface{}, d *Decoder) {
+	v, changed := f.DecMapBoolIntfV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolIntfV(v map[bool]interface{}, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolIntfV(v map[bool]interface{}, canChange bool,
 	d *Decoder) (_ map[bool]interface{}, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
@@ -35173,22 +32078,29 @@ func (_ fastpathT) DecMapBoolIntfV(v map[bool]interface{}, checkNil bool, canCha
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
 	var mk bool
 	var mv interface{}
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeBool()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = nil
+			}
+			continue
 		}
 		if mapGet {
 			mv = v[mk]
@@ -35200,41 +32112,30 @@ func (_ fastpathT) DecMapBoolIntfV(v map[bool]interface{}, checkNil bool, canCha
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolStringR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[bool]string)
-		v, changed := fastpathTV.DecMapBoolStringV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapBoolStringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]string)
+		v, changed := fastpathTV.DecMapBoolStringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[bool]string)
-		fastpathTV.DecMapBoolStringV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapBoolStringV(rv2i(rv).(map[bool]string), false, d)
 	}
 }
-func (f fastpathT) DecMapBoolStringX(vp *map[bool]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolStringV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapBoolStringX(vp *map[bool]string, d *Decoder) {
+	v, changed := f.DecMapBoolStringV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolStringV(v map[bool]string, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolStringV(v map[bool]string, canChange bool,
 	d *Decoder) (_ map[bool]string, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
@@ -35242,63 +32143,58 @@ func (_ fastpathT) DecMapBoolStringV(v map[bool]string, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk bool
 	var mv string
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeBool()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = ""
+			}
+			continue
 		}
 		mv = dd.DecodeString()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolUintR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[bool]uint)
-		v, changed := fastpathTV.DecMapBoolUintV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapBoolUintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]uint)
+		v, changed := fastpathTV.DecMapBoolUintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[bool]uint)
-		fastpathTV.DecMapBoolUintV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapBoolUintV(rv2i(rv).(map[bool]uint), false, d)
 	}
 }
-func (f fastpathT) DecMapBoolUintX(vp *map[bool]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolUintV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapBoolUintX(vp *map[bool]uint, d *Decoder) {
+	v, changed := f.DecMapBoolUintV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolUintV(v map[bool]uint, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolUintV(v map[bool]uint, canChange bool,
 	d *Decoder) (_ map[bool]uint, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -35306,63 +32202,58 @@ func (_ fastpathT) DecMapBoolUintV(v map[bool]uint, checkNil bool, canChange boo
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk bool
 	var mv uint
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeBool()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolUint8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[bool]uint8)
-		v, changed := fastpathTV.DecMapBoolUint8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapBoolUint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]uint8)
+		v, changed := fastpathTV.DecMapBoolUint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[bool]uint8)
-		fastpathTV.DecMapBoolUint8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapBoolUint8V(rv2i(rv).(map[bool]uint8), false, d)
 	}
 }
-func (f fastpathT) DecMapBoolUint8X(vp *map[bool]uint8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolUint8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapBoolUint8X(vp *map[bool]uint8, d *Decoder) {
+	v, changed := f.DecMapBoolUint8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolUint8V(v map[bool]uint8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolUint8V(v map[bool]uint8, canChange bool,
 	d *Decoder) (_ map[bool]uint8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
@@ -35370,63 +32261,58 @@ func (_ fastpathT) DecMapBoolUint8V(v map[bool]uint8, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk bool
 	var mv uint8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeBool()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint8(dd.DecodeUint(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolUint16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[bool]uint16)
-		v, changed := fastpathTV.DecMapBoolUint16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapBoolUint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]uint16)
+		v, changed := fastpathTV.DecMapBoolUint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[bool]uint16)
-		fastpathTV.DecMapBoolUint16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapBoolUint16V(rv2i(rv).(map[bool]uint16), false, d)
 	}
 }
-func (f fastpathT) DecMapBoolUint16X(vp *map[bool]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolUint16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapBoolUint16X(vp *map[bool]uint16, d *Decoder) {
+	v, changed := f.DecMapBoolUint16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolUint16V(v map[bool]uint16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolUint16V(v map[bool]uint16, canChange bool,
 	d *Decoder) (_ map[bool]uint16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
@@ -35434,63 +32320,58 @@ func (_ fastpathT) DecMapBoolUint16V(v map[bool]uint16, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk bool
 	var mv uint16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeBool()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint16(dd.DecodeUint(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolUint32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[bool]uint32)
-		v, changed := fastpathTV.DecMapBoolUint32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapBoolUint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]uint32)
+		v, changed := fastpathTV.DecMapBoolUint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[bool]uint32)
-		fastpathTV.DecMapBoolUint32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapBoolUint32V(rv2i(rv).(map[bool]uint32), false, d)
 	}
 }
-func (f fastpathT) DecMapBoolUint32X(vp *map[bool]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolUint32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapBoolUint32X(vp *map[bool]uint32, d *Decoder) {
+	v, changed := f.DecMapBoolUint32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolUint32V(v map[bool]uint32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolUint32V(v map[bool]uint32, canChange bool,
 	d *Decoder) (_ map[bool]uint32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
@@ -35498,63 +32379,58 @@ func (_ fastpathT) DecMapBoolUint32V(v map[bool]uint32, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk bool
 	var mv uint32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeBool()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uint32(dd.DecodeUint(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolUint64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[bool]uint64)
-		v, changed := fastpathTV.DecMapBoolUint64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapBoolUint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]uint64)
+		v, changed := fastpathTV.DecMapBoolUint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[bool]uint64)
-		fastpathTV.DecMapBoolUint64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapBoolUint64V(rv2i(rv).(map[bool]uint64), false, d)
 	}
 }
-func (f fastpathT) DecMapBoolUint64X(vp *map[bool]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolUint64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapBoolUint64X(vp *map[bool]uint64, d *Decoder) {
+	v, changed := f.DecMapBoolUint64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolUint64V(v map[bool]uint64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolUint64V(v map[bool]uint64, canChange bool,
 	d *Decoder) (_ map[bool]uint64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -35562,63 +32438,58 @@ func (_ fastpathT) DecMapBoolUint64V(v map[bool]uint64, checkNil bool, canChange
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk bool
 	var mv uint64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeBool()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeUint(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolUintptrR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[bool]uintptr)
-		v, changed := fastpathTV.DecMapBoolUintptrV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapBoolUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]uintptr)
+		v, changed := fastpathTV.DecMapBoolUintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[bool]uintptr)
-		fastpathTV.DecMapBoolUintptrV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapBoolUintptrV(rv2i(rv).(map[bool]uintptr), false, d)
 	}
 }
-func (f fastpathT) DecMapBoolUintptrX(vp *map[bool]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolUintptrV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapBoolUintptrX(vp *map[bool]uintptr, d *Decoder) {
+	v, changed := f.DecMapBoolUintptrV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolUintptrV(v map[bool]uintptr, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolUintptrV(v map[bool]uintptr, canChange bool,
 	d *Decoder) (_ map[bool]uintptr, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -35626,63 +32497,58 @@ func (_ fastpathT) DecMapBoolUintptrV(v map[bool]uintptr, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk bool
 	var mv uintptr
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeBool()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = uintptr(dd.DecodeUint(uintBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolIntR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[bool]int)
-		v, changed := fastpathTV.DecMapBoolIntV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapBoolIntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]int)
+		v, changed := fastpathTV.DecMapBoolIntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[bool]int)
-		fastpathTV.DecMapBoolIntV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapBoolIntV(rv2i(rv).(map[bool]int), false, d)
 	}
 }
-func (f fastpathT) DecMapBoolIntX(vp *map[bool]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolIntV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapBoolIntX(vp *map[bool]int, d *Decoder) {
+	v, changed := f.DecMapBoolIntV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolIntV(v map[bool]int, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolIntV(v map[bool]int, canChange bool,
 	d *Decoder) (_ map[bool]int, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -35690,63 +32556,58 @@ func (_ fastpathT) DecMapBoolIntV(v map[bool]int, checkNil bool, canChange bool,
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk bool
 	var mv int
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeBool()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int(dd.DecodeInt(intBitsize))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolInt8R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[bool]int8)
-		v, changed := fastpathTV.DecMapBoolInt8V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapBoolInt8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]int8)
+		v, changed := fastpathTV.DecMapBoolInt8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[bool]int8)
-		fastpathTV.DecMapBoolInt8V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapBoolInt8V(rv2i(rv).(map[bool]int8), false, d)
 	}
 }
-func (f fastpathT) DecMapBoolInt8X(vp *map[bool]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolInt8V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapBoolInt8X(vp *map[bool]int8, d *Decoder) {
+	v, changed := f.DecMapBoolInt8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolInt8V(v map[bool]int8, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolInt8V(v map[bool]int8, canChange bool,
 	d *Decoder) (_ map[bool]int8, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
@@ -35754,63 +32615,58 @@ func (_ fastpathT) DecMapBoolInt8V(v map[bool]int8, checkNil bool, canChange boo
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk bool
 	var mv int8
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeBool()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int8(dd.DecodeInt(8))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolInt16R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[bool]int16)
-		v, changed := fastpathTV.DecMapBoolInt16V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapBoolInt16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]int16)
+		v, changed := fastpathTV.DecMapBoolInt16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[bool]int16)
-		fastpathTV.DecMapBoolInt16V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapBoolInt16V(rv2i(rv).(map[bool]int16), false, d)
 	}
 }
-func (f fastpathT) DecMapBoolInt16X(vp *map[bool]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolInt16V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapBoolInt16X(vp *map[bool]int16, d *Decoder) {
+	v, changed := f.DecMapBoolInt16V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolInt16V(v map[bool]int16, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolInt16V(v map[bool]int16, canChange bool,
 	d *Decoder) (_ map[bool]int16, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
@@ -35818,63 +32674,58 @@ func (_ fastpathT) DecMapBoolInt16V(v map[bool]int16, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk bool
 	var mv int16
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeBool()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int16(dd.DecodeInt(16))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolInt32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[bool]int32)
-		v, changed := fastpathTV.DecMapBoolInt32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapBoolInt32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]int32)
+		v, changed := fastpathTV.DecMapBoolInt32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[bool]int32)
-		fastpathTV.DecMapBoolInt32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapBoolInt32V(rv2i(rv).(map[bool]int32), false, d)
 	}
 }
-func (f fastpathT) DecMapBoolInt32X(vp *map[bool]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolInt32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapBoolInt32X(vp *map[bool]int32, d *Decoder) {
+	v, changed := f.DecMapBoolInt32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolInt32V(v map[bool]int32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolInt32V(v map[bool]int32, canChange bool,
 	d *Decoder) (_ map[bool]int32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
@@ -35882,63 +32733,58 @@ func (_ fastpathT) DecMapBoolInt32V(v map[bool]int32, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk bool
 	var mv int32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeBool()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = int32(dd.DecodeInt(32))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolInt64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[bool]int64)
-		v, changed := fastpathTV.DecMapBoolInt64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapBoolInt64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]int64)
+		v, changed := fastpathTV.DecMapBoolInt64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[bool]int64)
-		fastpathTV.DecMapBoolInt64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapBoolInt64V(rv2i(rv).(map[bool]int64), false, d)
 	}
 }
-func (f fastpathT) DecMapBoolInt64X(vp *map[bool]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolInt64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapBoolInt64X(vp *map[bool]int64, d *Decoder) {
+	v, changed := f.DecMapBoolInt64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolInt64V(v map[bool]int64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolInt64V(v map[bool]int64, canChange bool,
 	d *Decoder) (_ map[bool]int64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -35946,63 +32792,58 @@ func (_ fastpathT) DecMapBoolInt64V(v map[bool]int64, checkNil bool, canChange b
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk bool
 	var mv int64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeBool()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
 		}
 		mv = dd.DecodeInt(64)
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolFloat32R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[bool]float32)
-		v, changed := fastpathTV.DecMapBoolFloat32V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapBoolFloat32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]float32)
+		v, changed := fastpathTV.DecMapBoolFloat32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[bool]float32)
-		fastpathTV.DecMapBoolFloat32V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapBoolFloat32V(rv2i(rv).(map[bool]float32), false, d)
 	}
 }
-func (f fastpathT) DecMapBoolFloat32X(vp *map[bool]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolFloat32V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapBoolFloat32X(vp *map[bool]float32, d *Decoder) {
+	v, changed := f.DecMapBoolFloat32V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolFloat32V(v map[bool]float32, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolFloat32V(v map[bool]float32, canChange bool,
 	d *Decoder) (_ map[bool]float32, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
@@ -36010,63 +32851,58 @@ func (_ fastpathT) DecMapBoolFloat32V(v map[bool]float32, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk bool
 	var mv float32
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeBool()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = float32(dd.DecodeFloat(true))
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = float32(chkFloat32(dd.DecodeFloat64()))
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolFloat64R(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[bool]float64)
-		v, changed := fastpathTV.DecMapBoolFloat64V(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapBoolFloat64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]float64)
+		v, changed := fastpathTV.DecMapBoolFloat64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[bool]float64)
-		fastpathTV.DecMapBoolFloat64V(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapBoolFloat64V(rv2i(rv).(map[bool]float64), false, d)
 	}
 }
-func (f fastpathT) DecMapBoolFloat64X(vp *map[bool]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolFloat64V(*vp, checkNil, true, d)
+func (f fastpathT) DecMapBoolFloat64X(vp *map[bool]float64, d *Decoder) {
+	v, changed := f.DecMapBoolFloat64V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolFloat64V(v map[bool]float64, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolFloat64V(v map[bool]float64, canChange bool,
 	d *Decoder) (_ map[bool]float64, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
@@ -36074,63 +32910,58 @@ func (_ fastpathT) DecMapBoolFloat64V(v map[bool]float64, checkNil bool, canChan
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk bool
 	var mv float64
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeBool()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
 		}
-		mv = dd.DecodeFloat(false)
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
+			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
 
-func (f *decFnInfo) fastpathDecMapBoolBoolR(rv reflect.Value) {
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[bool]bool)
-		v, changed := fastpathTV.DecMapBoolBoolV(*vp, fastpathCheckNilFalse, true, f.d)
+func (d *Decoder) fastpathDecMapBoolBoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]bool)
+		v, changed := fastpathTV.DecMapBoolBoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv2i(rv).(map[bool]bool)
-		fastpathTV.DecMapBoolBoolV(v, fastpathCheckNilFalse, false, f.d)
+		fastpathTV.DecMapBoolBoolV(rv2i(rv).(map[bool]bool), false, d)
 	}
 }
-func (f fastpathT) DecMapBoolBoolX(vp *map[bool]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecMapBoolBoolV(*vp, checkNil, true, d)
+func (f fastpathT) DecMapBoolBoolX(vp *map[bool]bool, d *Decoder) {
+	v, changed := f.DecMapBoolBoolV(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecMapBoolBoolV(v map[bool]bool, checkNil bool, canChange bool,
+func (_ fastpathT) DecMapBoolBoolV(v map[bool]bool, canChange bool,
 	d *Decoder) (_ map[bool]bool, changed bool) {
-	dd := d.d
-	cr := d.cr
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		}
-		return nil, changed
-	}
+	dd, esep := d.d, d.hh.hasElemSeparators()
 	containerLen := dd.ReadMapStart()
 	if canChange && v == nil {
 		xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
@@ -36138,30 +32969,34 @@ func (_ fastpathT) DecMapBoolBoolV(v map[bool]bool, checkNil bool, canChange boo
 		changed = true
 	}
 	if containerLen == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		dd.ReadMapEnd()
 		return v, changed
 	}
-
 	var mk bool
 	var mv bool
 	hasLen := containerLen > 0
 	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil {
-			cr.sendContainerState(containerMapKey)
+		if esep {
+			dd.ReadMapElemKey()
 		}
 		mk = dd.DecodeBool()
-		if cr != nil {
-			cr.sendContainerState(containerMapValue)
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = false
+			}
+			continue
 		}
 		mv = dd.DecodeBool()
 		if v != nil {
 			v[mk] = mv
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	dd.ReadMapEnd()
 	return v, changed
 }
diff --git a/vendor/github.com/ugorji/go/codec/fast-path.go.tmpl b/vendor/github.com/ugorji/go/codec/fast-path.go.tmpl
deleted file mode 100644
index 0ce15ded0..000000000
--- a/vendor/github.com/ugorji/go/codec/fast-path.go.tmpl
+++ /dev/null
@@ -1,473 +0,0 @@
-// +build !notfastpath
-
-// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
-// Use of this source code is governed by a MIT license found in the LICENSE file.
-
-// ************************************************************
-// DO NOT EDIT. 
-// THIS FILE IS AUTO-GENERATED from fast-path.go.tmpl
-// ************************************************************
-
-package codec
-
-// Fast path functions try to create a fast path encode or decode implementation
-// for common maps and slices.
-//
-// We define the functions and register then in this single file
-// so as not to pollute the encode.go and decode.go, and create a dependency in there.
-// This file can be omitted without causing a build failure.
-//
-// The advantage of fast paths is:
-//    - Many calls bypass reflection altogether
-// 
-// Currently support
-//    - slice of all builtin types,
-//    - map of all builtin types to string or interface value
-//    - symmetrical maps of all builtin types (e.g. str-str, uint8-uint8)
-// This should provide adequate "typical" implementations.
-// 
-// Note that fast track decode functions must handle values for which an address cannot be obtained.
-// For example: 
-//   m2 := map[string]int{}
-//   p2 := []interface{}{m2}
-//   // decoding into p2 will bomb if fast track functions do not treat like unaddressable.
-// 
-
-import (
-	"reflect"
-	"sort"
-)
-
-const fastpathEnabled = true
-
-const fastpathCheckNilFalse = false // for reflect
-const fastpathCheckNilTrue = true // for type switch
-
-type fastpathT struct {}
-
-var fastpathTV fastpathT
-
-type fastpathE struct {
-	rtid uintptr
-	rt reflect.Type 
-	encfn func(*encFnInfo, reflect.Value)
-	decfn func(*decFnInfo, reflect.Value)
-}
-
-type fastpathA [{{ .FastpathLen }}]fastpathE
-
-func (x *fastpathA) index(rtid uintptr) int {
-	// use binary search to grab the index (adapted from sort/search.go)
-	h, i, j := 0, 0, {{ .FastpathLen }} // len(x)
-	for i < j {
-		h = i + (j-i)/2
-		if x[h].rtid < rtid {
-			i = h + 1
-		} else {
-			j = h
-		}
-	}
-	if i < {{ .FastpathLen }} && x[i].rtid == rtid {
-		return i
-	}
-	return -1
-}
-
-type fastpathAslice []fastpathE
-
-func (x fastpathAslice) Len() int { return len(x) }
-func (x fastpathAslice) Less(i, j int) bool { return x[i].rtid < x[j].rtid }
-func (x fastpathAslice) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
-
-var fastpathAV fastpathA
-
-// due to possible initialization loop error, make fastpath in an init()
-func init() {
-	i := 0
-	fn := func(v interface{}, fe func(*encFnInfo, reflect.Value), fd func(*decFnInfo, reflect.Value)) (f fastpathE) {
-		xrt := reflect.TypeOf(v)
-		xptr := rt2id(xrt)
-		fastpathAV[i] = fastpathE{xptr, xrt, fe, fd}
-		i++
-		return
-	}
-	
-	{{range .Values}}{{if not .Primitive}}{{if not .MapKey }}
-	fn([]{{ .Elem }}(nil), (*encFnInfo).{{ .MethodNamePfx "fastpathEnc" false }}R, (*decFnInfo).{{ .MethodNamePfx "fastpathDec" false }}R){{end}}{{end}}{{end}}
-	
-	{{range .Values}}{{if not .Primitive}}{{if .MapKey }}
-	fn(map[{{ .MapKey }}]{{ .Elem }}(nil), (*encFnInfo).{{ .MethodNamePfx "fastpathEnc" false }}R, (*decFnInfo).{{ .MethodNamePfx "fastpathDec" false }}R){{end}}{{end}}{{end}}
-	
-	sort.Sort(fastpathAslice(fastpathAV[:]))
-}
-
-// -- encode
-
-// -- -- fast path type switch
-func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool {
-	switch v := iv.(type) {
-{{range .Values}}{{if not .Primitive}}{{if not .MapKey }}
-	case []{{ .Elem }}:{{else}}
-	case map[{{ .MapKey }}]{{ .Elem }}:{{end}}
-		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(v, fastpathCheckNilTrue, e){{if not .MapKey }}
-	case *[]{{ .Elem }}:{{else}}
-	case *map[{{ .MapKey }}]{{ .Elem }}:{{end}}
-		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(*v, fastpathCheckNilTrue, e)
-{{end}}{{end}}
-	default:
-        _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
-		return false
-	}
-	return true
-}
-
-func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool {
-	switch v := iv.(type) {
-{{range .Values}}{{if not .Primitive}}{{if not .MapKey }}
-	case []{{ .Elem }}:
-		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(v, fastpathCheckNilTrue, e)
-	case *[]{{ .Elem }}:
-		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(*v, fastpathCheckNilTrue, e)
-{{end}}{{end}}{{end}}
-	default:
-        _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
-		return false
-	}
-	return true
-}
-
-func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool {
-	switch v := iv.(type) {
-{{range .Values}}{{if not .Primitive}}{{if .MapKey }}
-	case map[{{ .MapKey }}]{{ .Elem }}:
-		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(v, fastpathCheckNilTrue, e)
-	case *map[{{ .MapKey }}]{{ .Elem }}:
-		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(*v, fastpathCheckNilTrue, e)
-{{end}}{{end}}{{end}}
-	default:
-        _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
-		return false
-	}
-	return true
-}
-
-// -- -- fast path functions
-{{range .Values}}{{if not .Primitive}}{{if not .MapKey }} 
-
-func (f *encFnInfo) {{ .MethodNamePfx "fastpathEnc" false }}R(rv reflect.Value) {
-	if f.ti.mbs {
-		fastpathTV.{{ .MethodNamePfx "EncAsMap" false }}V(rv2i(rv).([]{{ .Elem }}), fastpathCheckNilFalse, f.e)
-	} else {
-		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(rv2i(rv).([]{{ .Elem }}), fastpathCheckNilFalse, f.e)
-	}
-}
-func (_ fastpathT) {{ .MethodNamePfx "Enc" false }}V(v []{{ .Elem }}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeArrayStart(len(v))
-	for _, v2 := range v {
-		if cr != nil { cr.sendContainerState(containerArrayElem) }
-		{{ encmd .Elem "v2"}}
-	}
-	if cr != nil { cr.sendContainerState(containerArrayEnd) }{{/* ee.EncodeEnd() */}}
-}
-
-func (_ fastpathT) {{ .MethodNamePfx "EncAsMap" false }}V(v []{{ .Elem }}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	if len(v)%2 == 1 {
-		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
-		return
-	}
-	ee.EncodeMapStart(len(v) / 2)
-	for j, v2 := range v {
-		if cr != nil {
-			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
-			} else {
-				cr.sendContainerState(containerMapValue)
-			}
-		}
-		{{ encmd .Elem "v2"}}
-	}
-	if cr != nil { cr.sendContainerState(containerMapEnd) }
-}
-
-{{end}}{{end}}{{end}}
-
-{{range .Values}}{{if not .Primitive}}{{if .MapKey }}
-
-func (f *encFnInfo) {{ .MethodNamePfx "fastpathEnc" false }}R(rv reflect.Value) {
-	fastpathTV.{{ .MethodNamePfx "Enc" false }}V(rv2i(rv).(map[{{ .MapKey }}]{{ .Elem }}), fastpathCheckNilFalse, f.e)
-}
-func (_ fastpathT) {{ .MethodNamePfx "Enc" false }}V(v map[{{ .MapKey }}]{{ .Elem }}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
-		return
-	}
-	ee.EncodeMapStart(len(v))
-	{{if eq .MapKey "string"}}asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
-	{{end}}if e.h.Canonical {
-		{{if eq .MapKey "interface{}"}}{{/* out of band 
-		*/}}var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
-		e2 := NewEncoderBytes(&mksv, e.hh)
-		v2 := make([]bytesI, len(v))
-		var i, l int
-		var vp *bytesI {{/* put loop variables outside. seems currently needed for better perf */}}
-		for k2, _ := range v {
-			l = len(mksv)
-			e2.MustEncode(k2)
-			vp = &v2[i]
-			vp.v = mksv[l:]
-			vp.i = k2 
-			i++
-		}
-		sort.Sort(bytesISlice(v2))
-		for j := range v2 {
-			if cr != nil { cr.sendContainerState(containerMapKey) }
-			e.asis(v2[j].v)
-			if cr != nil { cr.sendContainerState(containerMapValue) }
-			e.encode(v[v2[j].i])
-		} {{else}}{{ $x := sorttype .MapKey true}}v2 := make([]{{ $x }}, len(v))
-		var i int 
-		for k, _ := range v {
-			v2[i] = {{ $x }}(k)
-			i++
-		}
-		sort.Sort({{ sorttype .MapKey false}}(v2))
-		for _, k2 := range v2 {
-			if cr != nil { cr.sendContainerState(containerMapKey) }
-			{{if eq .MapKey "string"}}if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
-			}{{else}}{{ $y := printf "%s(k2)" .MapKey }}{{ encmd .MapKey $y }}{{end}}
-			if cr != nil { cr.sendContainerState(containerMapValue) }
-			{{ $y := printf "v[%s(k2)]" .MapKey }}{{ encmd .Elem $y }}
-		} {{end}}
-	} else {
-		for k2, v2 := range v {
-			if cr != nil { cr.sendContainerState(containerMapKey) }
-			{{if eq .MapKey "string"}}if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
-			}{{else}}{{ encmd .MapKey "k2"}}{{end}}
-			if cr != nil { cr.sendContainerState(containerMapValue) }
-			{{ encmd .Elem "v2"}}
-		}
-	}
-	if cr != nil { cr.sendContainerState(containerMapEnd) }{{/* ee.EncodeEnd() */}}
-}
-
-{{end}}{{end}}{{end}}
-
-// -- decode
-
-// -- -- fast path type switch
-func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool {
-	switch v := iv.(type) {
-{{range .Values}}{{if not .Primitive}}{{if not .MapKey }}
-	case []{{ .Elem }}:{{else}}
-	case map[{{ .MapKey }}]{{ .Elem }}:{{end}}
-		fastpathTV.{{ .MethodNamePfx "Dec" false }}V(v, fastpathCheckNilFalse, false, d){{if not .MapKey }}
-	case *[]{{ .Elem }}:{{else}}
-	case *map[{{ .MapKey }}]{{ .Elem }}:{{end}}
-		v2, changed2 := fastpathTV.{{ .MethodNamePfx "Dec" false }}V(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
-			*v = v2 
-		}
-{{end}}{{end}}
-	default:
-        _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
-		return false
-	}
-	return true
-}
-
-// -- -- fast path functions
-{{range .Values}}{{if not .Primitive}}{{if not .MapKey }}
-{{/*
-Slices can change if they 
-- did not come from an array
-- are addressable (from a ptr)
-- are settable (e.g. contained in an interface{})
-*/}}
-func (f *decFnInfo) {{ .MethodNamePfx "fastpathDec" false }}R(rv reflect.Value) { 
-	array := f.seq == seqTypeArray
-	if !array && rv.CanAddr() { {{/* // CanSet => CanAddr + Exported */}}
-		vp := rv2i(rv.Addr()).(*[]{{ .Elem }})
-		v, changed := fastpathTV.{{ .MethodNamePfx "Dec" false }}V(*vp, fastpathCheckNilFalse, !array, f.d)
-		if changed {
-			*vp = v
-		}
-	} else {
-		v := rv2i(rv).([]{{ .Elem }})
-		fastpathTV.{{ .MethodNamePfx "Dec" false }}V(v, fastpathCheckNilFalse, false, f.d)
-	}
-}
-
-func (f fastpathT) {{ .MethodNamePfx "Dec" false }}X(vp *[]{{ .Elem }}, checkNil bool, d *Decoder) {
-	v, changed := f.{{ .MethodNamePfx "Dec" false }}V(*vp, checkNil, true, d)
-	if changed {
-		*vp = v 
-	}
-}
-func (_ fastpathT) {{ .MethodNamePfx "Dec" false }}V(v []{{ .Elem }}, checkNil bool, canChange bool, d *Decoder) (_ []{{ .Elem }}, changed bool) {
-	dd := d.d
-	{{/* // if dd.isContainerType(valueTypeNil) { dd.TryDecodeAsNil() */}}
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil { changed = true }
-		return nil, changed 
-	}
-	slh, containerLenS := d.decSliceHelperStart()
-	if containerLenS == 0 {
-		if canChange {
-			if v == nil { 
-				v = []{{ .Elem }}{}
-			} else if len(v) != 0 {
-				v = v[:0]
-			}
-			changed = true
-		}
-		slh.End()
-		return v, changed
-	}
-
-	hasLen := containerLenS > 0
-	var xlen int 
-	if hasLen && canChange {
-		if containerLenS > cap(v) {
-			xlen = decInferLen(containerLenS, d.h.MaxInitLen, {{ .Size }})
-			if xlen <= cap(v) {
-				v = v[:xlen]
-			} else {
-				v = make([]{{ .Elem }}, xlen)
-			}
-			changed = true 
-		} else if containerLenS != len(v) {
-			v = v[:containerLenS]
-			changed = true
-		}
-	}
-	j := 0
-	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
-		if j == 0 && len(v) == 0 {
-			if hasLen {
-				xlen = decInferLen(containerLenS, d.h.MaxInitLen, {{ .Size }})
-			} else {
-				xlen = 8
-			}
-			v = make([]{{ .Elem }}, xlen)
-			changed = true 
-		}
-		// if indefinite, etc, then expand the slice if necessary
-		var decodeIntoBlank bool
-		if j >= len(v) {
-			if canChange {
-				v = append(v, {{ zerocmd .Elem }})
-				changed = true
-			} else {
-				d.arrayCannotExpand(len(v), j+1)
-				decodeIntoBlank = true
-			}
-		}
-		slh.ElemContainerState(j)
-		if decodeIntoBlank {
-			d.swallow()
-		} else {
-			{{ if eq .Elem "interface{}" }}d.decode(&v[j]){{ else }}v[j] = {{ decmd .Elem }}{{ end }}
-		}
-	}
-	if canChange {
-		if j < len(v) {
-			v = v[:j]
-			changed = true
-		} else if j == 0 && v == nil {
-			v = make([]{{ .Elem }}, 0)
-			changed = true
-		}
-	}
-	slh.End()
-	return v, changed 
-}
-
-{{end}}{{end}}{{end}}
-
-
-{{range .Values}}{{if not .Primitive}}{{if .MapKey }}
-{{/*
-Maps can change if they are
-- addressable (from a ptr)
-- settable (e.g. contained in an interface{})
-*/}}
-func (f *decFnInfo) {{ .MethodNamePfx "fastpathDec" false }}R(rv reflect.Value) { 
-	if rv.CanAddr() {
-		vp := rv2i(rv.Addr()).(*map[{{ .MapKey }}]{{ .Elem }})
-		v, changed := fastpathTV.{{ .MethodNamePfx "Dec" false }}V(*vp, fastpathCheckNilFalse, true, f.d)
-		if changed {
-			*vp = v
-		}
-	} else {
-		v := rv2i(rv).(map[{{ .MapKey }}]{{ .Elem }})
-		fastpathTV.{{ .MethodNamePfx "Dec" false }}V(v, fastpathCheckNilFalse, false, f.d)
-	}
-}
-func (f fastpathT) {{ .MethodNamePfx "Dec" false }}X(vp *map[{{ .MapKey }}]{{ .Elem }}, checkNil bool, d *Decoder) {
-	v, changed := f.{{ .MethodNamePfx "Dec" false }}V(*vp, checkNil, true, d)
-	if changed {
-		*vp = v 
-	}
-}
-func (_ fastpathT) {{ .MethodNamePfx "Dec" false }}V(v map[{{ .MapKey }}]{{ .Elem }}, checkNil bool, canChange bool, 
-	d *Decoder) (_ map[{{ .MapKey }}]{{ .Elem }}, changed bool) {
-	dd := d.d
-	cr := d.cr
-	{{/* // if dd.isContainerType(valueTypeNil) {dd.TryDecodeAsNil() */}}
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil { changed = true } 
-		return nil, changed
-	}
-	containerLen := dd.ReadMapStart()
-	if canChange && v == nil {
-		xlen := decInferLen(containerLen, d.h.MaxInitLen, {{ .Size }})
-		v = make(map[{{ .MapKey }}]{{ .Elem }}, xlen)
-		changed = true
-	}
-	if containerLen == 0 {
-		if cr != nil { cr.sendContainerState(containerMapEnd) }
-		return v, changed
-	}
-	{{ if eq .Elem "interface{}" }}mapGet := !d.h.MapValueReset && !d.h.InterfaceReset{{end}}
-	var mk {{ .MapKey }}
-	var mv {{ .Elem }}
-	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
-		if cr != nil { cr.sendContainerState(containerMapKey) }
-		{{ if eq .MapKey "interface{}" }}mk = nil 
-		d.decode(&mk)
-		if bv, bok := mk.([]byte); bok {
-			mk = d.string(bv) {{/* // maps cannot have []byte as key. switch to string. */}}
-		}{{ else }}mk = {{ decmd .MapKey }}{{ end }}
-		if cr != nil { cr.sendContainerState(containerMapValue) }
-		{{ if eq .Elem "interface{}" }}if mapGet { mv = v[mk] } else { mv = nil }
-		d.decode(&mv){{ else }}mv = {{ decmd .Elem }}{{ end }}
-		if v != nil {
-			v[mk] = mv
-		}
-	}
-	if cr != nil { cr.sendContainerState(containerMapEnd) }
-	return v, changed
-}
-
-{{end}}{{end}}{{end}}
diff --git a/vendor/github.com/ugorji/go/codec/fast-path.not.go b/vendor/github.com/ugorji/go/codec/fast-path.not.go
index 63e591145..2e78833d2 100644
--- a/vendor/github.com/ugorji/go/codec/fast-path.not.go
+++ b/vendor/github.com/ugorji/go/codec/fast-path.not.go
@@ -18,17 +18,27 @@ func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool      { return fal
 func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool      { return false }
 func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool { return false }
 func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool   { return false }
+func fastpathDecodeSetZeroTypeSwitch(iv interface{}) bool           { return false }
 
 type fastpathT struct{}
 type fastpathE struct {
 	rtid  uintptr
 	rt    reflect.Type
-	encfn func(*encFnInfo, reflect.Value)
-	decfn func(*decFnInfo, reflect.Value)
+	encfn func(*Encoder, *codecFnInfo, reflect.Value)
+	decfn func(*Decoder, *codecFnInfo, reflect.Value)
 }
 type fastpathA [0]fastpathE
 
 func (x fastpathA) index(rtid uintptr) int { return -1 }
 
+func (_ fastpathT) DecSliceUint8V(v []uint8, canChange bool, d *Decoder) (_ []uint8, changed bool) {
+	fn := d.cf.get(uint8SliceTyp, true, true)
+	d.kSlice(&fn.i, reflect.ValueOf(&v).Elem())
+	return v, true
+}
+
 var fastpathAV fastpathA
 var fastpathTV fastpathT
+
+// ----
+type TestMammoth2Wrapper struct{} // to allow testMammoth work in notfastpath mode
diff --git a/vendor/github.com/ugorji/go/codec/gen-dec-array.go.tmpl b/vendor/github.com/ugorji/go/codec/gen-dec-array.go.tmpl
deleted file mode 100644
index f4f0cdd27..000000000
--- a/vendor/github.com/ugorji/go/codec/gen-dec-array.go.tmpl
+++ /dev/null
@@ -1,70 +0,0 @@
-{{var "v"}} := {{if not isArray}}*{{end}}{{ .Varname }}
-{{var "h"}}, {{var "l"}} := z.DecSliceHelperStart() {{/* // helper, containerLenS */}}{{if not isArray}}
-var {{var "c"}} bool {{/* // changed */}}
-_ = {{var "c"}}{{end}}
-if {{var "l"}} == 0 {
-	{{if isSlice }}if {{var "v"}} == nil {
-		{{var "v"}} = []{{ .Typ }}{}
-		{{var "c"}} = true
-	} else if len({{var "v"}}) != 0 {
-		{{var "v"}} = {{var "v"}}[:0]
-		{{var "c"}} = true
-	} {{end}} {{if isChan }}if {{var "v"}} == nil {
-		{{var "v"}} = make({{ .CTyp }}, 0)
-		{{var "c"}} = true
-	} {{end}}
-} else {
-	{{var "hl"}} := {{var "l"}} > 0
-	var {{var "rl"}} int 
-	{{if isSlice }} if {{var "hl"}} {
-	if {{var "l"}} > cap({{var "v"}}) {
-		{{var "rl"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
-		if {{var "rl"}} <= cap({{var "v"}}) {
-			{{var "v"}} = {{var "v"}}[:{{var "rl"}}]
-		} else {
-			{{var "v"}} = make([]{{ .Typ }}, {{var "rl"}})
-		}
-		{{var "c"}} = true
-	} else if {{var "l"}} != len({{var "v"}}) {
-		{{var "v"}} = {{var "v"}}[:{{var "l"}}]
-		{{var "c"}} = true
-	}
-	} {{end}}
-	{{var "j"}} := 0
-	for ; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || r.CheckBreak()); {{var "j"}}++ {
-		if {{var "j"}} == 0 && len({{var "v"}}) == 0 {
-			if {{var "hl"}} {
-				{{var "rl"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
-			} else {
-				{{var "rl"}} = 8
-			}
-			{{var "v"}} = make([]{{ .Typ }}, {{var "rl"}})
-			{{var "c"}} = true 
-		}
-		// if indefinite, etc, then expand the slice if necessary
-		var {{var "db"}} bool
-		if {{var "j"}} >= len({{var "v"}}) {
-			{{if isSlice }} {{var "v"}} = append({{var "v"}}, {{ zero }}); {{var "c"}} = true
-			{{end}} {{if isArray}} z.DecArrayCannotExpand(len(v), {{var "j"}}+1); {{var "db"}} = true
-			{{end}}
-		}
-		{{var "h"}}.ElemContainerState({{var "j"}})
-		if {{var "db"}} {
-			z.DecSwallow()
-		} else {
-			{{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x }}
-		}
-	}
-	{{if isSlice}} if {{var "j"}} < len({{var "v"}}) {
-		{{var "v"}} = {{var "v"}}[:{{var "j"}}]
-		{{var "c"}} = true
-	} else if {{var "j"}} == 0 && {{var "v"}} == nil {
-		{{var "v"}} = make([]{{ .Typ }}, 0)
-		{{var "c"}} = true
-	} {{end}}
-}
-{{var "h"}}.End()
-{{if not isArray }}if {{var "c"}} { 
-	*{{ .Varname }} = {{var "v"}}
-}{{end}}
-
diff --git a/vendor/github.com/ugorji/go/codec/gen-dec-map.go.tmpl b/vendor/github.com/ugorji/go/codec/gen-dec-map.go.tmpl
deleted file mode 100644
index 423d63852..000000000
--- a/vendor/github.com/ugorji/go/codec/gen-dec-map.go.tmpl
+++ /dev/null
@@ -1,39 +0,0 @@
-{{var "v"}} := *{{ .Varname }}
-{{var "l"}} := r.ReadMapStart()
-{{var "bh"}} := z.DecBasicHandle()
-if {{var "v"}} == nil {
-	{{var "rl"}} := z.DecInferLen({{var "l"}}, {{var "bh"}}.MaxInitLen, {{ .Size }})
-	{{var "v"}} = make(map[{{ .KTyp }}]{{ .Typ }}, {{var "rl"}})
-	*{{ .Varname }} = {{var "v"}}
-}
-var {{var "mk"}} {{ .KTyp }}
-var {{var "mv"}} {{ .Typ }}
-var {{var "mg"}} {{if decElemKindPtr}}, {{var "ms"}}, {{var "mok"}}{{end}} bool
-if {{var "bh"}}.MapValueReset {
-	{{if decElemKindPtr}}{{var "mg"}} = true
-	{{else if decElemKindIntf}}if !{{var "bh"}}.InterfaceReset { {{var "mg"}} = true }
-	{{else if not decElemKindImmutable}}{{var "mg"}} = true
-	{{end}} }
-if {{var "l"}} != 0 {
-{{var "hl"}} := {{var "l"}} > 0 
-	for {{var "j"}} := 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || r.CheckBreak()); {{var "j"}}++ {
-	z.DecSendContainerState(codecSelfer_containerMapKey{{ .Sfx }})
-	{{ $x := printf "%vmk%v" .TempVar .Rand }}{{ decLineVarK $x }}
-{{ if eq .KTyp "interface{}" }}{{/* // special case if a byte array. */}}if {{var "bv"}}, {{var "bok"}} := {{var "mk"}}.([]byte); {{var "bok"}} {
-		{{var "mk"}} = string({{var "bv"}})
-	}{{ end }}{{if decElemKindPtr}}
-	{{var "ms"}} = true{{end}}
-	if {{var "mg"}} {
-		{{if decElemKindPtr}}{{var "mv"}}, {{var "mok"}} = {{var "v"}}[{{var "mk"}}] 
-		if {{var "mok"}} {
-			{{var "ms"}} = false
-		} {{else}}{{var "mv"}} = {{var "v"}}[{{var "mk"}}] {{end}}
-	} {{if not decElemKindImmutable}}else { {{var "mv"}} = {{decElemZero}} }{{end}}
-	z.DecSendContainerState(codecSelfer_containerMapValue{{ .Sfx }})
-	{{ $x := printf "%vmv%v" .TempVar .Rand }}{{ decLineVar $x }}
-	if {{if decElemKindPtr}} {{var "ms"}} && {{end}} {{var "v"}} != nil {
-		{{var "v"}}[{{var "mk"}}] = {{var "mv"}}
-	}
-}
-} // else len==0: TODO: Should we clear map entries?
-z.DecSendContainerState(codecSelfer_containerMapEnd{{ .Sfx }})
diff --git a/vendor/github.com/ugorji/go/codec/gen-helper.generated.go b/vendor/github.com/ugorji/go/codec/gen-helper.generated.go
index fee017a2a..4c6fc1ddf 100644
--- a/vendor/github.com/ugorji/go/codec/gen-helper.generated.go
+++ b/vendor/github.com/ugorji/go/codec/gen-helper.generated.go
@@ -3,10 +3,7 @@
 // Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
 // Use of this source code is governed by a MIT license found in the LICENSE file.
 
-// ************************************************************
-// DO NOT EDIT.
-// THIS FILE IS AUTO-GENERATED from gen-helper.go.tmpl
-// ************************************************************
+// Code generated from gen-helper.go.tmpl - DO NOT EDIT.
 
 package codec
 
@@ -16,7 +13,7 @@ import (
 )
 
 // GenVersion is the current version of codecgen.
-const GenVersion = 6
+const GenVersion = 8
 
 // This file is used to generate helper code for codecgen.
 // The values here i.e. genHelper(En|De)coder are not to be used directly by
@@ -28,18 +25,54 @@ const GenVersion = 6
 // When static codecs are created for types, they will use this value
 // to perform encoding or decoding of primitives or known slice or map types.
 
+type genHelperEncDriver struct {
+	encDriver
+}
+
+func (x genHelperEncDriver) EncodeBuiltin(rt uintptr, v interface{}) {}
+func (x genHelperEncDriver) EncStructFieldKey(keyType valueType, s string) {
+	encStructFieldKey(x.encDriver, keyType, s, false)
+}
+
+type genHelperDecDriver struct {
+	decDriver
+}
+
+func (x genHelperDecDriver) DecodeBuiltin(rt uintptr, v interface{}) {}
+func (x genHelperDecDriver) DecStructFieldKey(keyType valueType, buf *[scratchByteArrayLen]byte) []byte {
+	return decStructFieldKey(x.decDriver, keyType, buf)
+}
+func (x genHelperDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) {
+	f = x.DecodeFloat64()
+	if chkOverflow32 && chkOvf.Float32(f) {
+		panicv.errorf("float32 overflow: %v", f)
+	}
+	return
+}
+func (x genHelperDecDriver) DecodeFloat32As64() (f float64) {
+	f = x.DecodeFloat64()
+	if chkOvf.Float32(f) {
+		panicv.errorf("float32 overflow: %v", f)
+	}
+	return
+}
+
 // GenHelperEncoder is exported so that it can be used externally by codecgen.
 //
 // Library users: DO NOT USE IT DIRECTLY. IT WILL CHANGE CONTINOUSLY WITHOUT NOTICE.
-func GenHelperEncoder(e *Encoder) (genHelperEncoder, encDriver) {
-	return genHelperEncoder{e: e}, e.e
+func GenHelperEncoder(e *Encoder) (ge genHelperEncoder, ee genHelperEncDriver) {
+	ge = genHelperEncoder{e: e}
+	ee = genHelperEncDriver{e.e}
+	return
 }
 
 // GenHelperDecoder is exported so that it can be used externally by codecgen.
 //
 // Library users: DO NOT USE IT DIRECTLY. IT WILL CHANGE CONTINOUSLY WITHOUT NOTICE.
-func GenHelperDecoder(d *Decoder) (genHelperDecoder, decDriver) {
-	return genHelperDecoder{d: d}, d.d
+func GenHelperDecoder(d *Decoder) (gd genHelperDecoder, dd genHelperDecDriver) {
+	gd = genHelperDecoder{d: d}
+	dd = genHelperDecDriver{d.d}
+	return
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
@@ -61,77 +94,89 @@ func (f genHelperEncoder) EncBasicHandle() *BasicHandle {
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) EncBinary() bool {
-	return f.e.be // f.e.hh.isBinaryEncoding()
+	return f.e.cf.be // f.e.hh.isBinaryEncoding()
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) EncFallback(iv interface{}) {
 	// println(">>>>>>>>> EncFallback")
-	f.e.encodeI(iv, false, false)
+	// f.e.encodeI(iv, false, false)
+	f.e.encodeValue(reflect.ValueOf(iv), nil, false)
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) EncTextMarshal(iv encoding.TextMarshaler) {
 	bs, fnerr := iv.MarshalText()
-	f.e.marshal(bs, fnerr, false, c_UTF8)
+	f.e.marshal(bs, fnerr, false, cUTF8)
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) EncJSONMarshal(iv jsonMarshaler) {
 	bs, fnerr := iv.MarshalJSON()
-	f.e.marshal(bs, fnerr, true, c_UTF8)
+	f.e.marshal(bs, fnerr, true, cUTF8)
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) EncBinaryMarshal(iv encoding.BinaryMarshaler) {
 	bs, fnerr := iv.MarshalBinary()
-	f.e.marshal(bs, fnerr, false, c_RAW)
+	f.e.marshal(bs, fnerr, false, cRAW)
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncRaw(iv Raw) {
-	f.e.raw(iv)
-}
+func (f genHelperEncoder) EncRaw(iv Raw) { f.e.rawBytes(iv) }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) TimeRtidIfBinc() uintptr {
-	if _, ok := f.e.hh.(*BincHandle); ok {
-		return timeTypId
-	}
-	return 0
-}
+//
+// Deprecated: builtin no longer supported - so we make this method a no-op,
+// but leave in-place so that old generated files continue to work without regeneration.
+func (f genHelperEncoder) TimeRtidIfBinc() (v uintptr) { return }
+
+// func (f genHelperEncoder) TimeRtidIfBinc() uintptr {
+// 	if _, ok := f.e.hh.(*BincHandle); ok {
+// 		return timeTypId
+// 	}
+// }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) IsJSONHandle() bool {
-	return f.e.js
+	return f.e.cf.js
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) I2Rtid(v interface{}) uintptr {
+	return i2rtid(v)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) Extension(rtid uintptr) (xfn *extTypeTagFn) {
+	return f.e.h.getExt(rtid)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncExtension(v interface{}, xfFn *extTypeTagFn) {
+	f.e.e.EncodeExt(v, xfFn.tag, xfFn.ext, f.e)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+//
+// Deprecated: No longer used,
+// but leave in-place so that old generated files continue to work without regeneration.
 func (f genHelperEncoder) HasExtensions() bool {
 	return len(f.e.h.extHandle) != 0
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+//
+// Deprecated: No longer used,
+// but leave in-place so that old generated files continue to work without regeneration.
 func (f genHelperEncoder) EncExt(v interface{}) (r bool) {
-	rt := reflect.TypeOf(v)
-	if rt.Kind() == reflect.Ptr {
-		rt = rt.Elem()
-	}
-	rtid := rt2id(rt)
-	if xfFn := f.e.h.getExt(rtid); xfFn != nil {
+	if xfFn := f.e.h.getExt(i2rtid(v)); xfFn != nil {
 		f.e.e.EncodeExt(v, xfFn.tag, xfFn.ext, f.e)
 		return true
 	}
 	return false
 }
 
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncSendContainerState(c containerState) {
-	if f.e.cr != nil {
-		f.e.cr.sendContainerState(c)
-	}
-}
-
 // ---------------- DECODER FOLLOWS -----------------
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
@@ -145,19 +190,27 @@ func (f genHelperDecoder) DecBinary() bool {
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecSwallow() {
-	f.d.swallow()
-}
+func (f genHelperDecoder) DecSwallow() { f.d.swallow() }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecScratchBuffer() []byte {
 	return f.d.b[:]
 }
 
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecScratchArrayBuffer() *[scratchByteArrayLen]byte {
+	return &f.d.b
+}
+
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecFallback(iv interface{}, chkPtr bool) {
 	// println(">>>>>>>>> DecFallback")
-	f.d.decodeI(iv, chkPtr, false, false, false)
+	rv := reflect.ValueOf(iv)
+	if chkPtr {
+		rv = f.d.ensureDecodeable(rv)
+	}
+	f.d.decodeValue(rv, nil, false)
+	// f.d.decodeValueFallback(rv)
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
@@ -202,17 +255,21 @@ func (f genHelperDecoder) DecBinaryUnmarshal(bm encoding.BinaryUnmarshaler) {
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecRaw() []byte {
-	return f.d.raw()
-}
+func (f genHelperDecoder) DecRaw() []byte { return f.d.rawBytes() }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) TimeRtidIfBinc() uintptr {
-	if _, ok := f.d.hh.(*BincHandle); ok {
-		return timeTypId
-	}
-	return 0
-}
+//
+// Deprecated: builtin no longer supported - so we make this method a no-op,
+// but leave in-place so that old generated files continue to work without regeneration.
+func (f genHelperDecoder) TimeRtidIfBinc() (v uintptr) { return }
+
+// func (f genHelperDecoder) TimeRtidIfBinc() uintptr {
+// 	// Note: builtin is no longer supported - so make this a no-op
+// 	if _, ok := f.d.hh.(*BincHandle); ok {
+// 		return timeTypId
+// 	}
+// 	return 0
+// }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) IsJSONHandle() bool {
@@ -220,15 +277,34 @@ func (f genHelperDecoder) IsJSONHandle() bool {
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) I2Rtid(v interface{}) uintptr {
+	return i2rtid(v)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) Extension(rtid uintptr) (xfn *extTypeTagFn) {
+	return f.d.h.getExt(rtid)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecExtension(v interface{}, xfFn *extTypeTagFn) {
+	f.d.d.DecodeExt(v, xfFn.tag, xfFn.ext)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+//
+// Deprecated: No longer used,
+// but leave in-place so that old generated files continue to work without regeneration.
 func (f genHelperDecoder) HasExtensions() bool {
 	return len(f.d.h.extHandle) != 0
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+//
+// Deprecated: No longer used,
+// but leave in-place so that old generated files continue to work without regeneration.
 func (f genHelperDecoder) DecExt(v interface{}) (r bool) {
-	rt := reflect.TypeOf(v).Elem()
-	rtid := rt2id(rt)
-	if xfFn := f.d.h.getExt(rtid); xfFn != nil {
+	if xfFn := f.d.h.getExt(i2rtid(v)); xfFn != nil {
 		f.d.d.DecodeExt(v, xfFn.tag, xfFn.ext)
 		return true
 	}
@@ -241,13 +317,7 @@ func (f genHelperDecoder) DecInferLen(clen, maxlen, unit int) (rvlen int) {
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) StringView(v []byte) string {
-	return stringView(v)
-}
-
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecSendContainerState(c containerState) {
-	if f.d.cr != nil {
-		f.d.cr.sendContainerState(c)
-	}
-}
+//
+// Deprecated: no longer used,
+// but leave in-place so that old generated files continue to work without regeneration.
+func (f genHelperDecoder) StringView(v []byte) string { return stringView(v) }
diff --git a/vendor/github.com/ugorji/go/codec/gen-helper.go.tmpl b/vendor/github.com/ugorji/go/codec/gen-helper.go.tmpl
deleted file mode 100644
index 2d801c817..000000000
--- a/vendor/github.com/ugorji/go/codec/gen-helper.go.tmpl
+++ /dev/null
@@ -1,381 +0,0 @@
-/* // +build ignore */
-
-// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
-// Use of this source code is governed by a MIT license found in the LICENSE file.
-
-// ************************************************************
-// DO NOT EDIT.
-// THIS FILE IS AUTO-GENERATED from gen-helper.go.tmpl
-// ************************************************************
-
-package codec
-
-import (
-	"encoding"
-	"reflect"
-)
-
-// GenVersion is the current version of codecgen.
-const GenVersion = {{ .Version }} 
-
-// This file is used to generate helper code for codecgen. 
-// The values here i.e. genHelper(En|De)coder are not to be used directly by 
-// library users. They WILL change continuously and without notice.
-// 
-// To help enforce this, we create an unexported type with exported members.
-// The only way to get the type is via the one exported type that we control (somewhat).
-// 
-// When static codecs are created for types, they will use this value
-// to perform encoding or decoding of primitives or known slice or map types.
-
-// GenHelperEncoder is exported so that it can be used externally by codecgen.
-// 
-// Library users: DO NOT USE IT DIRECTLY. IT WILL CHANGE CONTINOUSLY WITHOUT NOTICE.
-func GenHelperEncoder(e *Encoder) (genHelperEncoder, encDriver) {
-	return genHelperEncoder{e:e}, e.e 
-}
-
-// GenHelperDecoder is exported so that it can be used externally by codecgen.
-// 
-// Library users: DO NOT USE IT DIRECTLY. IT WILL CHANGE CONTINOUSLY WITHOUT NOTICE.
-func GenHelperDecoder(d *Decoder) (genHelperDecoder, decDriver) {
-	return genHelperDecoder{d:d}, d.d 
-}
-
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-type genHelperEncoder struct {
-	e *Encoder
-	F fastpathT 
-}
-
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-type genHelperDecoder struct {
-	d *Decoder
-	F fastpathT 
-}
-
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncBasicHandle() *BasicHandle {
-	return f.e.h
-}
-
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncBinary() bool {
-	return f.e.be // f.e.hh.isBinaryEncoding()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncFallback(iv interface{}) {
-	// println(">>>>>>>>> EncFallback")
-	f.e.encodeI(iv, false, false)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncTextMarshal(iv encoding.TextMarshaler) {
-	bs, fnerr := iv.MarshalText()
-	f.e.marshal(bs, fnerr, false, c_UTF8)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncJSONMarshal(iv jsonMarshaler) {
-	bs, fnerr := iv.MarshalJSON()
-	f.e.marshal(bs, fnerr, true, c_UTF8)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncBinaryMarshal(iv encoding.BinaryMarshaler) {
-	bs, fnerr := iv.MarshalBinary()
-	f.e.marshal(bs, fnerr, false, c_RAW)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncRaw(iv Raw) {
-	f.e.raw(iv)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) TimeRtidIfBinc() uintptr {
-	if _, ok := f.e.hh.(*BincHandle); ok {
-		return timeTypId 
-	}
-	return 0
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) IsJSONHandle() bool {
-	return f.e.js
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) HasExtensions() bool {
-	return len(f.e.h.extHandle) != 0
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncExt(v interface{}) (r bool) {
-	rt := reflect.TypeOf(v)
-	if rt.Kind() == reflect.Ptr {
-		rt = rt.Elem()
-	}
-	rtid := rt2id(rt)
-	if xfFn := f.e.h.getExt(rtid); xfFn != nil {
-		f.e.e.EncodeExt(v, xfFn.tag, xfFn.ext, f.e)
-		return true
-	}
-	return false 
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncSendContainerState(c containerState) {
-	if f.e.cr != nil {
-		f.e.cr.sendContainerState(c)
-	}
-}
-
-// ---------------- DECODER FOLLOWS -----------------
-
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecBasicHandle() *BasicHandle {
-	return f.d.h
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecBinary() bool {
-     return f.d.be // f.d.hh.isBinaryEncoding()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecSwallow() {
-	f.d.swallow()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecScratchBuffer() []byte {
-	return f.d.b[:]
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecFallback(iv interface{}, chkPtr bool) {
-	// println(">>>>>>>>> DecFallback")
-	f.d.decodeI(iv, chkPtr, false, false, false)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecSliceHelperStart() (decSliceHelper, int) {
-	return f.d.decSliceHelperStart()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecStructFieldNotFound(index int, name string) {
-	f.d.structFieldNotFound(index, name)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecArrayCannotExpand(sliceLen, streamLen int) {
-	f.d.arrayCannotExpand(sliceLen, streamLen)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecTextUnmarshal(tm encoding.TextUnmarshaler) {
-	fnerr := tm.UnmarshalText(f.d.d.DecodeStringAsBytes())
-	if fnerr != nil {
-		panic(fnerr)
-	}
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecJSONUnmarshal(tm jsonUnmarshaler) {
-	// bs := f.dd.DecodeStringAsBytes()
-	// grab the bytes to be read, as UnmarshalJSON needs the full JSON so as to unmarshal it itself.
-	fnerr := tm.UnmarshalJSON(f.d.nextValueBytes())
-	if fnerr != nil {
-		panic(fnerr)
-	}
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecBinaryUnmarshal(bm encoding.BinaryUnmarshaler) {
-	fnerr := bm.UnmarshalBinary(f.d.d.DecodeBytes(nil, true))
-	if fnerr != nil {
-		panic(fnerr)
-	}
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecRaw() []byte {
-	return f.d.raw()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) TimeRtidIfBinc() uintptr {
-	if _, ok := f.d.hh.(*BincHandle); ok {
-		return timeTypId 
-	}
-	return 0
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) IsJSONHandle() bool {
-	return f.d.js 
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) HasExtensions() bool {
-	return len(f.d.h.extHandle) != 0
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecExt(v interface{}) (r bool) {
-	rt := reflect.TypeOf(v).Elem()
-	rtid := rt2id(rt)
-	if xfFn := f.d.h.getExt(rtid); xfFn != nil {
-		f.d.d.DecodeExt(v, xfFn.tag, xfFn.ext)
-		return true
-	}
-	return false 
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecInferLen(clen, maxlen, unit int) (rvlen int) {
-	return decInferLen(clen, maxlen, unit)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) StringView(v []byte) string {
-	return stringView(v)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecSendContainerState(c containerState) {
-	if f.d.cr != nil {
-		f.d.cr.sendContainerState(c)
-	}
-}
-
-{{/*
-
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncDriver() encDriver {
-	return f.e.e
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecDriver() decDriver {
-     return f.d.d
-}
-
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncNil() {
-	f.e.e.EncodeNil()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncBytes(v []byte) {
-	f.e.e.EncodeStringBytes(c_RAW, v)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncArrayStart(length int) {
-	f.e.e.EncodeArrayStart(length)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncArrayEnd() {
-	f.e.e.EncodeArrayEnd()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncArrayEntrySeparator() {
-	f.e.e.EncodeArrayEntrySeparator()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncMapStart(length int) {
-	f.e.e.EncodeMapStart(length)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncMapEnd() {
-	f.e.e.EncodeMapEnd()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncMapEntrySeparator() {
-	f.e.e.EncodeMapEntrySeparator()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncMapKVSeparator() {
-	f.e.e.EncodeMapKVSeparator()
-}
-
-// ---------
-
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecBytes(v *[]byte) {
-	*v = f.d.d.DecodeBytes(*v)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecTryNil() bool {
-	return f.d.d.TryDecodeAsNil()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecContainerIsNil() (b bool) {
-	return f.d.d.IsContainerType(valueTypeNil)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecContainerIsMap() (b bool) {
-	return f.d.d.IsContainerType(valueTypeMap)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecContainerIsArray() (b bool) {
-	return f.d.d.IsContainerType(valueTypeArray)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecCheckBreak() bool {
-	return f.d.d.CheckBreak()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecMapStart() int {
-	return f.d.d.ReadMapStart()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecArrayStart() int {
-	return f.d.d.ReadArrayStart()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecMapEnd() {
-	f.d.d.ReadMapEnd()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecArrayEnd() {
-	f.d.d.ReadArrayEnd()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecArrayEntrySeparator() {
-	f.d.d.ReadArrayEntrySeparator()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecMapEntrySeparator() {
-	f.d.d.ReadMapEntrySeparator()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecMapKVSeparator() {
-	f.d.d.ReadMapKVSeparator()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) ReadStringAsBytes(bs []byte) []byte {
-	return f.d.d.DecodeStringAsBytes(bs)
-}
-
-
-// -- encode calls (primitives)
-{{range .Values}}{{if .Primitive }}{{if ne .Primitive "interface{}" }}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) {{ .MethodNamePfx "Enc" true }}(v {{ .Primitive }}) {
-	ee := f.e.e
-	{{ encmd .Primitive "v" }}
-}
-{{ end }}{{ end }}{{ end }}
-
-// -- decode calls (primitives)
-{{range .Values}}{{if .Primitive }}{{if ne .Primitive "interface{}" }}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) {{ .MethodNamePfx "Dec" true }}(vp *{{ .Primitive }}) {
-	dd := f.d.d
-	*vp = {{ decmd .Primitive }}
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) {{ .MethodNamePfx "Read" true }}() (v {{ .Primitive }}) {
-	dd := f.d.d
-	v = {{ decmd .Primitive }}
-	return
-}
-{{ end }}{{ end }}{{ end }}
-
-
-// -- encode calls (slices/maps)
-{{range .Values}}{{if not .Primitive }}{{if .Slice }}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) {{ .MethodNamePfx "Enc" false }}(v []{{ .Elem }}) { {{ else }}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) {{ .MethodNamePfx "Enc" false }}(v map[{{ .MapKey }}]{{ .Elem }}) { {{end}}
-	f.F.{{ .MethodNamePfx "Enc" false }}V(v, false, f.e)
-}
-{{ end }}{{ end }}
-
-// -- decode calls (slices/maps) 
-{{range .Values}}{{if not .Primitive }}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-{{if .Slice }}func (f genHelperDecoder) {{ .MethodNamePfx "Dec" false }}(vp *[]{{ .Elem }}) { 
-{{else}}func (f genHelperDecoder) {{ .MethodNamePfx "Dec" false }}(vp *map[{{ .MapKey }}]{{ .Elem }}) { {{end}}
-	v, changed := f.F.{{ .MethodNamePfx "Dec" false }}V(*vp, false, true, f.d)
-	if changed {
-		*vp = v 
-	}
-}
-{{ end }}{{ end }}
-*/}}
diff --git a/vendor/github.com/ugorji/go/codec/gen.generated.go b/vendor/github.com/ugorji/go/codec/gen.generated.go
index 2a6123da8..2add68dd7 100644
--- a/vendor/github.com/ugorji/go/codec/gen.generated.go
+++ b/vendor/github.com/ugorji/go/codec/gen.generated.go
@@ -1,3 +1,5 @@
+// +build codecgen.exec
+
 // Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
 // Use of this source code is governed by a MIT license found in the LICENSE file.
 
@@ -16,7 +18,7 @@ if {{var "v"}} == nil {
 }
 var {{var "mk"}} {{ .KTyp }}
 var {{var "mv"}} {{ .Typ }}
-var {{var "mg"}} {{if decElemKindPtr}}, {{var "ms"}}, {{var "mok"}}{{end}} bool
+var {{var "mg"}}, {{var "mdn"}} {{if decElemKindPtr}}, {{var "ms"}}, {{var "mok"}}{{end}} bool
 if {{var "bh"}}.MapValueReset {
 	{{if decElemKindPtr}}{{var "mg"}} = true
 	{{else if decElemKindIntf}}if !{{var "bh"}}.InterfaceReset { {{var "mg"}} = true }
@@ -25,7 +27,7 @@ if {{var "bh"}}.MapValueReset {
 if {{var "l"}} != 0 {
 {{var "hl"}} := {{var "l"}} > 0 
 	for {{var "j"}} := 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || r.CheckBreak()); {{var "j"}}++ {
-	z.DecSendContainerState(codecSelfer_containerMapKey{{ .Sfx }})
+	r.ReadMapElemKey() {{/* z.DecSendContainerState(codecSelfer_containerMapKey{{ .Sfx }}) */}}
 	{{ $x := printf "%vmk%v" .TempVar .Rand }}{{ decLineVarK $x }}
 {{ if eq .KTyp "interface{}" }}{{/* // special case if a byte array. */}}if {{var "bv"}}, {{var "bok"}} := {{var "mk"}}.([]byte); {{var "bok"}} {
 		{{var "mk"}} = string({{var "bv"}})
@@ -37,14 +39,17 @@ if {{var "l"}} != 0 {
 			{{var "ms"}} = false
 		} {{else}}{{var "mv"}} = {{var "v"}}[{{var "mk"}}] {{end}}
 	} {{if not decElemKindImmutable}}else { {{var "mv"}} = {{decElemZero}} }{{end}}
-	z.DecSendContainerState(codecSelfer_containerMapValue{{ .Sfx }})
-	{{ $x := printf "%vmv%v" .TempVar .Rand }}{{ decLineVar $x }}
-	if {{if decElemKindPtr}} {{var "ms"}} && {{end}} {{var "v"}} != nil {
+	r.ReadMapElemValue() {{/* z.DecSendContainerState(codecSelfer_containerMapValue{{ .Sfx }}) */}}
+	{{var "mdn"}} = false
+	{{ $x := printf "%vmv%v" .TempVar .Rand }}{{ $y := printf "%vmdn%v" .TempVar .Rand }}{{ decLineVar $x $y }}
+	if {{var "mdn"}} {
+		if {{ var "bh" }}.DeleteOnNilMapValue { delete({{var "v"}}, {{var "mk"}}) } else { {{var "v"}}[{{var "mk"}}] = {{decElemZero}} }
+	} else if {{if decElemKindPtr}} {{var "ms"}} && {{end}} {{var "v"}} != nil {
 		{{var "v"}}[{{var "mk"}}] = {{var "mv"}}
 	}
 }
 } // else len==0: TODO: Should we clear map entries?
-z.DecSendContainerState(codecSelfer_containerMapEnd{{ .Sfx }})
+r.ReadMapEnd() {{/* z.DecSendContainerState(codecSelfer_containerMapEnd{{ .Sfx }}) */}}
 `
 
 const genDecListTmpl = `
@@ -65,7 +70,7 @@ if {{var "l"}} == 0 {
 	} {{end}}
 } else {
 	{{var "hl"}} := {{var "l"}} > 0
-	var {{var "rl"}} int 
+	var {{var "rl"}} int; _ =  {{var "rl"}}
 	{{if isSlice }} if {{var "hl"}} {
 	if {{var "l"}} > cap({{var "v"}}) {
 		{{var "rl"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
@@ -80,9 +85,10 @@ if {{var "l"}} == 0 {
 		{{var "c"}} = true
 	}
 	} {{end}}
-	{{var "j"}} := 0
+	var {{var "j"}} int 
+    // var {{var "dn"}} bool 
 	for ; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || r.CheckBreak()); {{var "j"}}++ {
-		if {{var "j"}} == 0 && len({{var "v"}}) == 0 {
+		{{if not isArray}} if {{var "j"}} == 0 && len({{var "v"}}) == 0 {
 			if {{var "hl"}} {
 				{{var "rl"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
 			} else {
@@ -90,20 +96,26 @@ if {{var "l"}} == 0 {
 			}
 			{{var "v"}} = make([]{{ .Typ }}, {{var "rl"}})
 			{{var "c"}} = true 
-		}
+		}{{end}}
+		{{var "h"}}.ElemContainerState({{var "j"}})
+        // {{var "dn"}} = r.TryDecodeAsNil()
+        {{if isChan}}{{ $x := printf "%[1]vv%[2]v" .TempVar .Rand }}var {{var $x}} {{ .Typ }}
+		{{ decLineVar $x }}
+		{{var "v"}} <- {{ $x }}
+        {{else}}
 		// if indefinite, etc, then expand the slice if necessary
 		var {{var "db"}} bool
 		if {{var "j"}} >= len({{var "v"}}) {
 			{{if isSlice }} {{var "v"}} = append({{var "v"}}, {{ zero }}); {{var "c"}} = true
-			{{end}} {{if isArray}} z.DecArrayCannotExpand(len(v), {{var "j"}}+1); {{var "db"}} = true
+			{{else}} z.DecArrayCannotExpand(len(v), {{var "j"}}+1); {{var "db"}} = true
 			{{end}}
 		}
-		{{var "h"}}.ElemContainerState({{var "j"}})
 		if {{var "db"}} {
 			z.DecSwallow()
 		} else {
 			{{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x }}
 		}
+        {{end}}
 	}
 	{{if isSlice}} if {{var "j"}} < len({{var "v"}}) {
 		{{var "v"}} = {{var "v"}}[:{{var "j"}}]
diff --git a/vendor/github.com/ugorji/go/codec/gen.go b/vendor/github.com/ugorji/go/codec/gen.go
index 8f1fd4f64..bf2c55056 100644
--- a/vendor/github.com/ugorji/go/codec/gen.go
+++ b/vendor/github.com/ugorji/go/codec/gen.go
@@ -30,7 +30,6 @@ import (
 // codecgen supports the full cycle of reflection-based codec:
 //    - RawExt
 //    - Raw
-//    - Builtins
 //    - Extensions
 //    - (Binary|Text|JSON)(Unm|M)arshal
 //    - generic by-kind
@@ -101,7 +100,7 @@ import (
 // v4: Removed separator support from (en|de)cDriver, and refactored codec(gen)
 // v5: changes to support faster json decoding. Let encoder/decoder maintain state of collections.
 // v6: removed unsafe from gen, and now uses codecgen.exec tag
-const genVersion = 6
+const genVersion = 8
 
 const (
 	genCodecPkg        = "codec1978"
@@ -129,10 +128,11 @@ const (
 )
 
 var (
-	genAllTypesSamePkgErr  = errors.New("All types must be in the same package")
-	genExpectArrayOrMapErr = errors.New("unexpected type. Expecting array/map/slice")
-	genBase64enc           = base64.NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789__")
-	genQNameRegex          = regexp.MustCompile(`[A-Za-z_.]+`)
+	errGenAllTypesSamePkg  = errors.New("All types must be in the same package")
+	errGenExpectArrayOrMap = errors.New("unexpected type. Expecting array/map/slice")
+
+	genBase64enc  = base64.NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789__")
+	genQNameRegex = regexp.MustCompile(`[A-Za-z_.]+`)
 )
 
 // genRunner holds some state used during a Gen run.
@@ -163,13 +163,16 @@ type genRunner struct {
 
 	ti *TypeInfos
 	// rr *rand.Rand // random generator for file-specific types
+
+	nx bool // no extensions
 }
 
 // Gen will write a complete go file containing Selfer implementations for each
 // type passed. All the types must be in the same package.
 //
-// Library users: DO NOT USE IT DIRECTLY. IT WILL CHANGE CONTINOUSLY WITHOUT NOTICE.
-func Gen(w io.Writer, buildTags, pkgName, uid string, ti *TypeInfos, typ ...reflect.Type) {
+// Library users: DO NOT USE IT DIRECTLY. IT WILL CHANGE CONTINUOUSLY WITHOUT NOTICE.
+func Gen(w io.Writer, buildTags, pkgName, uid string, noExtensions bool,
+	ti *TypeInfos, typ ...reflect.Type) {
 	// All types passed to this method do not have a codec.Selfer method implemented directly.
 	// codecgen already checks the AST and skips any types that define the codec.Selfer methods.
 	// Consequently, there's no need to check and trim them if they implement codec.Selfer
@@ -190,6 +193,7 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, ti *TypeInfos, typ ...refl
 		bp:  genImportPath(typ[0]),
 		xs:  uid,
 		ti:  ti,
+		nx:  noExtensions,
 	}
 	if x.ti == nil {
 		x.ti = defTypeInfos
@@ -205,7 +209,7 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, ti *TypeInfos, typ ...refl
 	for _, t := range typ {
 		// fmt.Printf("###########: PkgPath: '%v', Name: '%s'\n", genImportPath(t), t.Name())
 		if genImportPath(t) != x.bp {
-			panic(genAllTypesSamePkgErr)
+			panic(errGenAllTypesSamePkg)
 		}
 		x.genRefPkgs(t)
 	}
@@ -215,10 +219,7 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, ti *TypeInfos, typ ...refl
 	}
 	x.line(`
 
-// ************************************************************
-// DO NOT EDIT.
-// THIS FILE IS AUTO-GENERATED BY codecgen.
-// ************************************************************
+// Code generated by codecgen - DO NOT EDIT.
 
 `)
 	x.line("package " + pkgName)
@@ -230,7 +231,7 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, ti *TypeInfos, typ ...refl
 	}
 	// use a sorted set of im keys, so that we can get consistent output
 	imKeys := make([]string, 0, len(x.im))
-	for k, _ := range x.im {
+	for k := range x.im {
 		imKeys = append(imKeys, k)
 	}
 	sort.Strings(imKeys)
@@ -248,21 +249,28 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, ti *TypeInfos, typ ...refl
 
 	x.line("const (")
 	x.linef("// ----- content types ----")
-	x.linef("codecSelferC_UTF8%s = %v", x.xs, int64(c_UTF8))
-	x.linef("codecSelferC_RAW%s = %v", x.xs, int64(c_RAW))
+	x.linef("codecSelferCcUTF8%s = %v", x.xs, int64(cUTF8))
+	x.linef("codecSelferCcRAW%s = %v", x.xs, int64(cRAW))
 	x.linef("// ----- value types used ----")
-	x.linef("codecSelferValueTypeArray%s = %v", x.xs, int64(valueTypeArray))
-	x.linef("codecSelferValueTypeMap%s = %v", x.xs, int64(valueTypeMap))
-	x.linef("// ----- containerStateValues ----")
-	x.linef("codecSelfer_containerMapKey%s = %v", x.xs, int64(containerMapKey))
-	x.linef("codecSelfer_containerMapValue%s = %v", x.xs, int64(containerMapValue))
-	x.linef("codecSelfer_containerMapEnd%s = %v", x.xs, int64(containerMapEnd))
-	x.linef("codecSelfer_containerArrayElem%s = %v", x.xs, int64(containerArrayElem))
-	x.linef("codecSelfer_containerArrayEnd%s = %v", x.xs, int64(containerArrayEnd))
+	for _, vt := range [...]valueType{
+		valueTypeArray, valueTypeMap, valueTypeString,
+		valueTypeInt, valueTypeUint, valueTypeFloat} {
+		x.linef("codecSelferValueType%s%s = %v", vt.String(), x.xs, int64(vt))
+	}
+
+	// x.linef("codecSelferValueTypeArray%s = %v", x.xs, int64(valueTypeArray))
+	// x.linef("codecSelferValueTypeMap%s = %v", x.xs, int64(valueTypeMap))
+	// // These are no longer needed, as there are functions created for them
+	// x.linef("// ----- containerStateValues ----")
+	// x.linef("codecSelferKcontainerMapKey%s = %v", x.xs, int64(containerMapKey))
+	// x.linef("codecSelferKcontainerMapValue%s = %v", x.xs, int64(containerMapValue))
+	// x.linef("codecSelferKcontainerMapEnd%s = %v", x.xs, int64(containerMapEnd))
+	// x.linef("codecSelferKcontainerArrayElem%s = %v", x.xs, int64(containerArrayElem))
+	// x.linef("codecSelferKcontainerArrayEnd%s = %v", x.xs, int64(containerArrayEnd))
 	x.line(")")
 	x.line("var (")
 	x.line("codecSelferBitsize" + x.xs + " = uint8(reflect.TypeOf(uint(0)).Bits())")
-	x.line("codecSelferOnlyMapOrArrayEncodeToStructErr" + x.xs + " = errors.New(`only encoded map or array can be decoded into a struct`)")
+	x.line("errCodecSelferOnlyMapOrArrayEncodeToStruct" + x.xs + " = errors.New(`only encoded map or array can be decoded into a struct`)")
 	x.line(")")
 	x.line("")
 
@@ -319,7 +327,7 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, ti *TypeInfos, typ ...refl
 		case reflect.Map:
 			x.encMapFallback("v", t)
 		default:
-			panic(genExpectArrayOrMapErr)
+			panic(errGenExpectArrayOrMap)
 		}
 		x.line("}")
 		x.line("")
@@ -334,7 +342,7 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, ti *TypeInfos, typ ...refl
 		case reflect.Map:
 			x.decMapFallback("v", rtid, t)
 		default:
-			panic(genExpectArrayOrMapErr)
+			panic(errGenExpectArrayOrMap)
 		}
 		x.line("}")
 		x.line("")
@@ -500,7 +508,7 @@ func (x *genRunner) selfer(encode bool) {
 	t0 := t
 	// always make decode use a pointer receiver,
 	// and structs always use a ptr receiver (encode|decode)
-	isptr := !encode || t.Kind() == reflect.Struct
+	isptr := !encode || (t.Kind() == reflect.Struct || t.Kind() == reflect.Array)
 	x.varsfxreset()
 	fnSigPfx := "func (x "
 	if isptr {
@@ -697,27 +705,41 @@ func (x *genRunner) enc(varname string, t reflect.Type) {
 	defer func() { x.line("}") }() //end if block
 
 	if t == rawTyp {
-		x.linef("} else { z.EncRaw(%v)", varname)
+		x.linef("} else { z.EncRaw(%s)", varname)
 		return
 	}
 	if t == rawExtTyp {
-		x.linef("} else { r.EncodeRawExt(%v, e)", varname)
+		x.linef("} else { r.EncodeRawExt(%s, e)", varname)
 		return
 	}
 	// HACK: Support for Builtins.
 	//       Currently, only Binc supports builtins, and the only builtin type is time.Time.
 	//       Have a method that returns the rtid for time.Time if Handle is Binc.
-	if t == timeTyp {
-		vrtid := genTempVarPfx + "m" + x.varsfx()
-		x.linef("} else if %s := z.TimeRtidIfBinc(); %s != 0 { ", vrtid, vrtid)
-		x.linef("r.EncodeBuiltin(%s, %s)", vrtid, varname)
-	}
+	// 2017-11-12: builtin no longer supported - comment out
+	// if t == timeTyp {
+	// 	vrtid := genTempVarPfx + "m" + x.varsfx()
+	// 	x.linef("} else if %s := z.TimeRtidIfBinc(); %s != 0 { ", vrtid, vrtid)
+	// 	x.linef("r.EncodeBuiltin(%s, *%s)", vrtid, varname)
+	// }
 	// only check for extensions if the type is named, and has a packagePath.
-	if genImportPath(t) != "" && t.Name() != "" {
+	var arrayOrStruct = tk == reflect.Array || tk == reflect.Struct // meaning varname if of type *T
+	if !x.nx && genImportPath(t) != "" && t.Name() != "" {
 		// first check if extensions are configued, before doing the interface conversion
-		x.linef("} else if z.HasExtensions() && z.EncExt(%s) {", varname)
+		// x.linef("} else if z.HasExtensions() && z.EncExt(%s) {", varname)
+		//
+		// yy := fmt.Sprintf("%sxt%s", genTempVarPfx, mi)
+		// // always pass a ptr, so if not array or struct, then take the address
+		// var zz string
+		// if !arrayOrStruct {
+		// 	// zz = "&" // taking address is more expensive. instead, let it optimize itself.
+		// }
+		// x.linef("} else if %s := z.Extension(z.I2Rtid(%s%s)); %s != nil { z.EncExtension(%s%s, %s) ",
+		// 	yy, zz, varname, yy, zz, varname, yy)
+		//
+		yy := fmt.Sprintf("%sxt%s", genTempVarPfx, mi)
+		x.linef("} else if %s := z.Extension(z.I2Rtid(%s)); %s != nil { z.EncExtension(%s, %s) ", yy, varname, yy, varname, yy)
 	}
-	if tk == reflect.Array || tk == reflect.Struct { // varname is of type *T
+	if arrayOrStruct { // varname is of type *T
 		if t.Implements(binaryMarshalerTyp) || tptr.Implements(binaryMarshalerTyp) {
 			x.linef("} else if %sm%s { z.EncBinaryMarshal(%v) ", genTempVarPfx, mi, varname)
 		}
@@ -756,7 +778,7 @@ func (x *genRunner) enc(varname string, t reflect.Type) {
 	case reflect.Bool:
 		x.line("r.EncodeBool(bool(" + varname + "))")
 	case reflect.String:
-		x.line("r.EncodeString(codecSelferC_UTF8" + x.xs + ", string(" + varname + "))")
+		x.line("r.EncodeString(codecSelferCcUTF8" + x.xs + ", string(" + varname + "))")
 	case reflect.Chan:
 		x.xtraSM(varname, true, t)
 		// x.encListFallback(varname, rtid, t)
@@ -770,10 +792,10 @@ func (x *genRunner) enc(varname string, t reflect.Type) {
 		// - if elements are primitives or Selfers, call dedicated function on each member.
 		// - else call Encoder.encode(XXX) on it.
 		if rtid == uint8SliceTypId {
-			x.line("r.EncodeStringBytes(codecSelferC_RAW" + x.xs + ", []byte(" + varname + "))")
+			x.line("r.EncodeStringBytes(codecSelferCcRAW" + x.xs + ", []byte(" + varname + "))")
 		} else if fastpathAV.index(rtid) != -1 {
 			g := x.newGenV(t)
-			x.line("z.F." + g.MethodNamePfx("Enc", false) + "V(" + varname + ", false, e)")
+			x.line("z.F." + g.MethodNamePfx("Enc", false) + "V(" + varname + ", e)")
 		} else {
 			x.xtraSM(varname, true, t)
 			// x.encListFallback(varname, rtid, t)
@@ -787,7 +809,7 @@ func (x *genRunner) enc(varname string, t reflect.Type) {
 		// x.line("if " + varname + " == nil { \nr.EncodeNil()\n } else { ")
 		if fastpathAV.index(rtid) != -1 {
 			g := x.newGenV(t)
-			x.line("z.F." + g.MethodNamePfx("Enc", false) + "V(" + varname + ", false, e)")
+			x.line("z.F." + g.MethodNamePfx("Enc", false) + "V(" + varname + ", e)")
 		} else {
 			x.xtraSM(varname, true, t)
 			// x.encMapFallback(varname, rtid, t)
@@ -820,7 +842,7 @@ func (x *genRunner) encZero(t reflect.Type) {
 	case reflect.Bool:
 		x.line("r.EncodeBool(false)")
 	case reflect.String:
-		x.line("r.EncodeString(codecSelferC_UTF8" + x.xs + `, "")`)
+		x.line("r.EncodeString(codecSelferCcUTF8" + x.xs + `, "")`)
 	default:
 		x.line("r.EncodeNil()")
 	}
@@ -845,55 +867,68 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) {
 	// number of non-empty things we write out first.
 	// This is required as we need to pre-determine the size of the container,
 	// to support length-prefixing.
-	x.linef("var %s [%v]bool", numfieldsvar, len(tisfi))
-	x.linef("_, _, _ = %s, %s, %s", sepVarname, numfieldsvar, struct2arrvar)
+	if ti.anyOmitEmpty {
+		x.linef("var %s [%v]bool", numfieldsvar, len(tisfi))
+		x.linef("_ = %s", numfieldsvar)
+	}
+	x.linef("_, _ = %s, %s", sepVarname, struct2arrvar)
 	x.linef("const %s bool = %v", ti2arrayvar, ti.toArray)
-	nn := 0
-	for j, si := range tisfi {
-		if !si.omitEmpty {
-			nn++
-			continue
-		}
-		var t2 reflect.StructField
-		var omitline string
-		if si.i != -1 {
-			t2 = t.Field(int(si.i))
-		} else {
-			t2typ := t
-			varname3 := varname
-			for _, ix := range si.is {
-				for t2typ.Kind() == reflect.Ptr {
-					t2typ = t2typ.Elem()
-				}
-				t2 = t2typ.Field(ix)
-				t2typ = t2.Type
-				varname3 = varname3 + "." + t2.Name
-				if t2typ.Kind() == reflect.Ptr {
-					omitline += varname3 + " != nil && "
+	var nn int
+	if ti.anyOmitEmpty {
+		for j, si := range tisfi {
+			if !si.omitEmpty {
+				nn++
+				continue
+			}
+			var t2 reflect.StructField
+			var omitline string
+			{
+				t2typ := t
+				varname3 := varname
+				// go through the loop, record the t2 field explicitly,
+				// and gather the omit line if embedded in pointers.
+				for ij, ix := range si.is {
+					if uint8(ij) == si.nis {
+						break
+					}
+					for t2typ.Kind() == reflect.Ptr {
+						t2typ = t2typ.Elem()
+					}
+					t2 = t2typ.Field(int(ix))
+					t2typ = t2.Type
+					varname3 = varname3 + "." + t2.Name
+					// do not include actual field in the omit line.
+					// that is done subsequently (right after - below).
+					if uint8(ij+1) < si.nis && t2typ.Kind() == reflect.Ptr {
+						omitline += varname3 + " != nil && "
+					}
 				}
 			}
+			// never check omitEmpty on a struct type, as it may contain uncomparable map/slice/etc.
+			// also, for maps/slices/arrays, check if len ! 0 (not if == zero value)
+			switch t2.Type.Kind() {
+			case reflect.Struct:
+				omitline += " true"
+			case reflect.Map, reflect.Slice, reflect.Array, reflect.Chan:
+				omitline += "len(" + varname + "." + t2.Name + ") != 0"
+			default:
+				omitline += varname + "." + t2.Name + " != " + x.genZeroValueR(t2.Type)
+			}
+			x.linef("%s[%v] = %s", numfieldsvar, j, omitline)
 		}
-		// never check omitEmpty on a struct type, as it may contain uncomparable map/slice/etc.
-		// also, for maps/slices/arrays, check if len ! 0 (not if == zero value)
-		switch t2.Type.Kind() {
-		case reflect.Struct:
-			omitline += " true"
-		case reflect.Map, reflect.Slice, reflect.Array, reflect.Chan:
-			omitline += "len(" + varname + "." + t2.Name + ") != 0"
-		default:
-			omitline += varname + "." + t2.Name + " != " + x.genZeroValueR(t2.Type)
-		}
-		x.linef("%s[%v] = %s", numfieldsvar, j, omitline)
 	}
-	x.linef("var %snn%s int", genTempVarPfx, i)
+	// x.linef("var %snn%s int", genTempVarPfx, i)
 	x.linef("if %s || %s {", ti2arrayvar, struct2arrvar) // if ti.toArray {
-	x.line("r.EncodeArrayStart(" + strconv.FormatInt(int64(len(tisfi)), 10) + ")")
+	x.linef("r.WriteArrayStart(%d)", len(tisfi))
 	x.linef("} else {") // if not ti.toArray
-	x.linef("%snn%s = %v", genTempVarPfx, i, nn)
-	x.linef("for _, b := range %s { if b { %snn%s++ } }", numfieldsvar, genTempVarPfx, i)
-	x.linef("r.EncodeMapStart(%snn%s)", genTempVarPfx, i)
-	x.linef("%snn%s = %v", genTempVarPfx, i, 0)
-	// x.line("r.EncodeMapStart(" + strconv.FormatInt(int64(len(tisfi)), 10) + ")")
+	if ti.anyOmitEmpty {
+		x.linef("var %snn%s = %v", genTempVarPfx, i, nn)
+		x.linef("for _, b := range %s { if b { %snn%s++ } }", numfieldsvar, genTempVarPfx, i)
+		x.linef("r.WriteMapStart(%snn%s)", genTempVarPfx, i)
+		x.linef("%snn%s = %v", genTempVarPfx, i, 0)
+	} else {
+		x.linef("r.WriteMapStart(%d)", len(tisfi))
+	}
 	x.line("}") // close if not StructToArray
 
 	for j, si := range tisfi {
@@ -901,17 +936,18 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) {
 		isNilVarName := genTempVarPfx + "n" + i
 		var labelUsed bool
 		var t2 reflect.StructField
-		if si.i != -1 {
-			t2 = t.Field(int(si.i))
-		} else {
+		{
 			t2typ := t
 			varname3 := varname
-			for _, ix := range si.is {
+			for ij, ix := range si.is {
+				if uint8(ij) == si.nis {
+					break
+				}
 				// fmt.Printf("%%%% %v, ix: %v\n", t2typ, ix)
 				for t2typ.Kind() == reflect.Ptr {
 					t2typ = t2typ.Elem()
 				}
-				t2 = t2typ.Field(ix)
+				t2 = t2typ.Field(int(ix))
 				t2typ = t2.Type
 				varname3 = varname3 + "." + t2.Name
 				if t2typ.Kind() == reflect.Ptr {
@@ -934,9 +970,10 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) {
 
 		x.linef("if %s || %s {", ti2arrayvar, struct2arrvar) // if ti.toArray
 		if labelUsed {
-			x.line("if " + isNilVarName + " { r.EncodeNil() } else { ")
+			x.linef("if %s { r.WriteArrayElem(); r.EncodeNil() } else { ", isNilVarName)
+			// x.linef("if %s { z.EncSendContainerState(codecSelferKcontainerArrayElem%s); r.EncodeNil() } else { ", isNilVarName, x.xs)
 		}
-		x.linef("z.EncSendContainerState(codecSelfer_containerArrayElem%s)", x.xs)
+		x.line("r.WriteArrayElem()") // x.linef("z.EncSendContainerState(codecSelferKcontainerArrayElem%s)", x.xs)
 		if si.omitEmpty {
 			x.linef("if %s[%v] {", numfieldsvar, j)
 		}
@@ -955,9 +992,10 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) {
 		if si.omitEmpty {
 			x.linef("if %s[%v] {", numfieldsvar, j)
 		}
-		x.linef("z.EncSendContainerState(codecSelfer_containerMapKey%s)", x.xs)
-		x.line("r.EncodeString(codecSelferC_UTF8" + x.xs + ", string(\"" + si.encName + "\"))")
-		x.linef("z.EncSendContainerState(codecSelfer_containerMapValue%s)", x.xs)
+		x.line("r.WriteMapElemKey()") // x.linef("z.EncSendContainerState(codecSelferKcontainerMapKey%s)", x.xs)
+		// x.line("r.EncodeString(codecSelferCcUTF8" + x.xs + ", `" + si.encName + "`)")
+		x.linef("r.EncStructFieldKey(codecSelferValueType%s%s, `%s`)", ti.keyType.String(), x.xs, si.encName)
+		x.line("r.WriteMapElemValue()") // x.linef("z.EncSendContainerState(codecSelferKcontainerMapValue%s)", x.xs)
 		if labelUsed {
 			x.line("if " + isNilVarName + " { r.EncodeNil() } else { ")
 			x.encVar(varname+"."+t2.Name, t2.Type)
@@ -971,54 +1009,54 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) {
 		x.linef("} ") // end if/else ti.toArray
 	}
 	x.linef("if %s || %s {", ti2arrayvar, struct2arrvar) // if ti.toArray {
-	x.linef("z.EncSendContainerState(codecSelfer_containerArrayEnd%s)", x.xs)
+	x.line("r.WriteArrayEnd()")                          // x.linef("z.EncSendContainerState(codecSelferKcontainerArrayEnd%s)", x.xs)
 	x.line("} else {")
-	x.linef("z.EncSendContainerState(codecSelfer_containerMapEnd%s)", x.xs)
+	x.line("r.WriteMapEnd()") // x.linef("z.EncSendContainerState(codecSelferKcontainerMapEnd%s)", x.xs)
 	x.line("}")
 
 }
 
 func (x *genRunner) encListFallback(varname string, t reflect.Type) {
 	if t.AssignableTo(uint8SliceTyp) {
-		x.linef("r.EncodeStringBytes(codecSelferC_RAW%s, []byte(%s))", x.xs, varname)
+		x.linef("r.EncodeStringBytes(codecSelferCcRAW%s, []byte(%s))", x.xs, varname)
 		return
 	}
 	if t.Kind() == reflect.Array && t.Elem().Kind() == reflect.Uint8 {
-		x.linef("r.EncodeStringBytes(codecSelferC_RAW%s, ([%v]byte(%s))[:])", x.xs, t.Len(), varname)
+		x.linef("r.EncodeStringBytes(codecSelferCcRAW%s, ((*[%d]byte)(%s))[:])", x.xs, t.Len(), varname)
 		return
 	}
 	i := x.varsfx()
 	g := genTempVarPfx
-	x.line("r.EncodeArrayStart(len(" + varname + "))")
+	x.line("r.WriteArrayStart(len(" + varname + "))")
 	if t.Kind() == reflect.Chan {
 		x.linef("for %si%s, %si2%s := 0, len(%s); %si%s < %si2%s; %si%s++ {", g, i, g, i, varname, g, i, g, i, g, i)
-		x.linef("z.EncSendContainerState(codecSelfer_containerArrayElem%s)", x.xs)
+		x.line("r.WriteArrayElem()") // x.linef("z.EncSendContainerState(codecSelferKcontainerArrayElem%s)", x.xs)
 		x.linef("%sv%s := <-%s", g, i, varname)
 	} else {
 		// x.linef("for %si%s, %sv%s := range %s {", genTempVarPfx, i, genTempVarPfx, i, varname)
 		x.linef("for _, %sv%s := range %s {", genTempVarPfx, i, varname)
-		x.linef("z.EncSendContainerState(codecSelfer_containerArrayElem%s)", x.xs)
+		x.line("r.WriteArrayElem()") // x.linef("z.EncSendContainerState(codecSelferKcontainerArrayElem%s)", x.xs)
 	}
 	x.encVar(genTempVarPfx+"v"+i, t.Elem())
 	x.line("}")
-	x.linef("z.EncSendContainerState(codecSelfer_containerArrayEnd%s)", x.xs)
+	x.line("r.WriteArrayEnd()") // x.linef("z.EncSendContainerState(codecSelferKcontainerArrayEnd%s)", x.xs)
 }
 
 func (x *genRunner) encMapFallback(varname string, t reflect.Type) {
 	// TODO: expand this to handle canonical.
 	i := x.varsfx()
-	x.line("r.EncodeMapStart(len(" + varname + "))")
+	x.line("r.WriteMapStart(len(" + varname + "))")
 	x.linef("for %sk%s, %sv%s := range %s {", genTempVarPfx, i, genTempVarPfx, i, varname)
 	// x.line("for " + genTempVarPfx + "k" + i + ", " + genTempVarPfx + "v" + i + " := range " + varname + " {")
-	x.linef("z.EncSendContainerState(codecSelfer_containerMapKey%s)", x.xs)
+	x.line("r.WriteMapElemKey()") // f("z.EncSendContainerState(codecSelferKcontainerMapKey%s)", x.xs)
 	x.encVar(genTempVarPfx+"k"+i, t.Key())
-	x.linef("z.EncSendContainerState(codecSelfer_containerMapValue%s)", x.xs)
+	x.line("r.WriteMapElemValue()") // f("z.EncSendContainerState(codecSelferKcontainerMapValue%s)", x.xs)
 	x.encVar(genTempVarPfx+"v"+i, t.Elem())
 	x.line("}")
-	x.linef("z.EncSendContainerState(codecSelfer_containerMapEnd%s)", x.xs)
+	x.line("r.WriteMapEnd()") // f("z.EncSendContainerState(codecSelferKcontainerMapEnd%s)", x.xs)
 }
 
-func (x *genRunner) decVar(varname string, t reflect.Type, canBeNil bool) {
+func (x *genRunner) decVar(varname, decodedNilVarname string, t reflect.Type, canBeNil bool) {
 	// We only encode as nil if a nillable value.
 	// This removes some of the wasted checks for TryDecodeAsNil.
 	// We need to think about this more, to see what happens if omitempty, etc
@@ -1031,7 +1069,9 @@ func (x *genRunner) decVar(varname string, t reflect.Type, canBeNil bool) {
 	}
 	if canBeNil {
 		x.line("if r.TryDecodeAsNil() {")
-		if t.Kind() == reflect.Ptr {
+		if decodedNilVarname != "" {
+			x.line(decodedNilVarname + " = true")
+		} else if t.Kind() == reflect.Ptr {
 			x.line("if " + varname + " != nil { ")
 
 			// if varname is a field of a struct (has a dot in it),
@@ -1143,15 +1183,18 @@ func (x *genRunner) dec(varname string, t reflect.Type) {
 	// HACK: Support for Builtins.
 	//       Currently, only Binc supports builtins, and the only builtin type is time.Time.
 	//       Have a method that returns the rtid for time.Time if Handle is Binc.
-	if t == timeTyp {
-		vrtid := genTempVarPfx + "m" + x.varsfx()
-		x.linef("} else if %s := z.TimeRtidIfBinc(); %s != 0 { ", vrtid, vrtid)
-		x.linef("r.DecodeBuiltin(%s, %s)", vrtid, varname)
-	}
+	// 2017-11-12: builtin no longer supported - comment out
+	// if t == timeTyp {
+	// 	vrtid := genTempVarPfx + "m" + x.varsfx()
+	// 	x.linef("} else if %s := z.TimeRtidIfBinc(); %s != 0 { ", vrtid, vrtid)
+	// 	x.linef("r.DecodeBuiltin(%s, %s)", vrtid, varname)
+	// }
 	// only check for extensions if the type is named, and has a packagePath.
-	if genImportPath(t) != "" && t.Name() != "" {
+	if !x.nx && genImportPath(t) != "" && t.Name() != "" {
 		// first check if extensions are configued, before doing the interface conversion
-		x.linef("} else if z.HasExtensions() && z.DecExt(%s) {", varname)
+		// x.linef("} else if z.HasExtensions() && z.DecExt(%s) {", varname)
+		yy := fmt.Sprintf("%sxt%s", genTempVarPfx, mi)
+		x.linef("} else if %s := z.Extension(z.I2Rtid(%s)); %s != nil { z.DecExtension(%s, %s) ", yy, varname, yy, varname, yy)
 	}
 
 	if t.Implements(binaryUnmarshalerTyp) || tptr.Implements(binaryUnmarshalerTyp) {
@@ -1202,10 +1245,10 @@ func (x *genRunner) dec(varname string, t reflect.Type) {
 		x.line("*((*uintptr)(" + varname + ")) = uintptr(r.DecodeUint(codecSelferBitsize" + x.xs + "))")
 
 	case reflect.Float32:
-		x.line("*((*float32)(" + varname + ")) = float32(r.DecodeFloat(true))")
+		x.line("*((*float32)(" + varname + ")) = float32(r.DecodeFloat32As64())")
 		//x.line("z.DecFloat32((*float32)(" + varname + "))")
 	case reflect.Float64:
-		x.line("*((*float64)(" + varname + ")) = float64(r.DecodeFloat(false))")
+		x.line("*((*float64)(" + varname + ")) = r.DecodeFloat64()")
 		// x.line("z.DecFloat64((*float64)(" + varname + "))")
 
 	case reflect.Bool:
@@ -1227,7 +1270,7 @@ func (x *genRunner) dec(varname string, t reflect.Type) {
 			x.line("*" + varname + " = r.DecodeBytes(*(*[]byte)(" + varname + "), false)")
 		} else if fastpathAV.index(rtid) != -1 {
 			g := x.newGenV(t)
-			x.line("z.F." + g.MethodNamePfx("Dec", false) + "X(" + varname + ", false, d)")
+			x.line("z.F." + g.MethodNamePfx("Dec", false) + "X(" + varname + ", d)")
 		} else {
 			x.xtraSM(varname, false, t)
 			// x.decListFallback(varname, rtid, false, t)
@@ -1239,7 +1282,7 @@ func (x *genRunner) dec(varname string, t reflect.Type) {
 		// - else call Encoder.encode(XXX) on it.
 		if fastpathAV.index(rtid) != -1 {
 			g := x.newGenV(t)
-			x.line("z.F." + g.MethodNamePfx("Dec", false) + "X(" + varname + ", false, d)")
+			x.line("z.F." + g.MethodNamePfx("Dec", false) + "X(" + varname + ", d)")
 		} else {
 			x.xtraSM(varname, false, t)
 			// x.decMapFallback(varname, rtid, t)
@@ -1295,9 +1338,9 @@ func (x *genRunner) decTryAssignPrimitive(varname string, t reflect.Type) (tryAs
 		x.linef("%s = r.DecodeUint(codecSelferBitsize%s)", varname, x.xs)
 
 	case reflect.Float32:
-		x.linef("%s = r.DecodeFloat(true)", varname)
+		x.linef("%s = r.DecodeFloat32As64()", varname)
 	case reflect.Float64:
-		x.linef("%s = r.DecodeFloat(false)", varname)
+		x.linef("%s = r.DecodeFloat64()", varname)
 
 	case reflect.Bool:
 		x.linef("%s = r.DecodeBool()", varname)
@@ -1315,7 +1358,7 @@ func (x *genRunner) decListFallback(varname string, rtid uintptr, t reflect.Type
 		return
 	}
 	if t.Kind() == reflect.Array && t.Elem().Kind() == reflect.Uint8 {
-		x.linef("r.DecodeBytes( ((*[%s]byte)(%s))[:], true)", t.Len(), varname)
+		x.linef("r.DecodeBytes( ((*[%d]byte)(%s))[:], true)", t.Len(), varname)
 		return
 	}
 	type tstruc struct {
@@ -1333,13 +1376,13 @@ func (x *genRunner) decListFallback(varname string, rtid uintptr, t reflect.Type
 	funcs := make(template.FuncMap)
 
 	funcs["decLineVar"] = func(varname string) string {
-		x.decVar(varname, telem, false)
-		return ""
-	}
-	funcs["decLine"] = func(pfx string) string {
-		x.decVar(ts.TempVar+pfx+ts.Rand, reflect.PtrTo(telem), false)
+		x.decVar(varname, "", telem, false)
 		return ""
 	}
+	// funcs["decLine"] = func(pfx string) string {
+	// 	x.decVar(ts.TempVar+pfx+ts.Rand, "", reflect.PtrTo(telem), false)
+	// 	return ""
+	// }
 	funcs["var"] = func(s string) string {
 		return ts.TempVar + s + ts.Rand
 	}
@@ -1395,21 +1438,21 @@ func (x *genRunner) decMapFallback(varname string, rtid uintptr, t reflect.Type)
 		return telem.Kind() == reflect.Interface
 	}
 	funcs["decLineVarK"] = func(varname string) string {
-		x.decVar(varname, tkey, false)
+		x.decVar(varname, "", tkey, false)
 		return ""
 	}
-	funcs["decLineVar"] = func(varname string) string {
-		x.decVar(varname, telem, false)
-		return ""
-	}
-	funcs["decLineK"] = func(pfx string) string {
-		x.decVar(ts.TempVar+pfx+ts.Rand, reflect.PtrTo(tkey), false)
-		return ""
-	}
-	funcs["decLine"] = func(pfx string) string {
-		x.decVar(ts.TempVar+pfx+ts.Rand, reflect.PtrTo(telem), false)
+	funcs["decLineVar"] = func(varname, decodedNilVarname string) string {
+		x.decVar(varname, decodedNilVarname, telem, false)
 		return ""
 	}
+	// funcs["decLineK"] = func(pfx string) string {
+	// 	x.decVar(ts.TempVar+pfx+ts.Rand, reflect.PtrTo(tkey), false)
+	// 	return ""
+	// }
+	// funcs["decLine"] = func(pfx string) string {
+	// 	x.decVar(ts.TempVar+pfx+ts.Rand, reflect.PtrTo(telem), false)
+	// 	return ""
+	// }
 	funcs["var"] = func(s string) string {
 		return ts.TempVar + s + ts.Rand
 	}
@@ -1430,18 +1473,19 @@ func (x *genRunner) decStructMapSwitch(kName string, varname string, rtid uintpt
 	for _, si := range tisfi {
 		x.line("case \"" + si.encName + "\":")
 		var t2 reflect.StructField
-		if si.i != -1 {
-			t2 = t.Field(int(si.i))
-		} else {
+		{
 			//we must accommodate anonymous fields, where the embedded field is a nil pointer in the value.
 			// t2 = t.FieldByIndex(si.is)
 			t2typ := t
 			varname3 := varname
-			for _, ix := range si.is {
+			for ij, ix := range si.is {
+				if uint8(ij) == si.nis {
+					break
+				}
 				for t2typ.Kind() == reflect.Ptr {
 					t2typ = t2typ.Elem()
 				}
-				t2 = t2typ.Field(ix)
+				t2 = t2typ.Field(int(ix))
 				t2typ = t2.Type
 				varname3 = varname3 + "." + t2.Name
 				if t2typ.Kind() == reflect.Ptr {
@@ -1449,7 +1493,7 @@ func (x *genRunner) decStructMapSwitch(kName string, varname string, rtid uintpt
 				}
 			}
 		}
-		x.decVar(varname+"."+t2.Name, t2.Type, false)
+		x.decVar(varname+"."+t2.Name, "", t2.Type, false)
 	}
 	x.line("default:")
 	// pass the slice here, so that the string will not escape, and maybe save allocation
@@ -1459,6 +1503,7 @@ func (x *genRunner) decStructMapSwitch(kName string, varname string, rtid uintpt
 
 func (x *genRunner) decStructMap(varname, lenvarname string, rtid uintptr, t reflect.Type, style genStructMapStyle) {
 	tpfx := genTempVarPfx
+	ti := x.ti.get(rtid, t)
 	i := x.varsfx()
 	kName := tpfx + "s" + i
 
@@ -1466,9 +1511,8 @@ func (x *genRunner) decStructMap(varname, lenvarname string, rtid uintptr, t ref
 	// x.line("var " + kName + "Slc = " + kName + "Arr[:] // default slice to decode into")
 	// use the scratch buffer to avoid allocation (most field names are < 32).
 
-	x.line("var " + kName + "Slc = z.DecScratchBuffer() // default slice to decode into")
-
-	x.line("_ = " + kName + "Slc")
+	// x.line("var " + kName + "Slc = z.DecScratchBuffer() // default slice to decode into")
+	// x.line("_ = " + kName + "Slc")
 	switch style {
 	case genStructMapStyleLenPrefix:
 		x.linef("for %sj%s := 0; %sj%s < %s; %sj%s++ {", tpfx, i, tpfx, i, lenvarname, tpfx, i)
@@ -1480,15 +1524,17 @@ func (x *genRunner) decStructMap(varname, lenvarname string, rtid uintptr, t ref
 		x.linef("if %shl%s { if %sj%s >= %s { break }", tpfx, i, tpfx, i, lenvarname)
 		x.line("} else { if r.CheckBreak() { break }; }")
 	}
-	x.linef("z.DecSendContainerState(codecSelfer_containerMapKey%s)", x.xs)
-	x.line(kName + "Slc = r.DecodeStringAsBytes()")
+	x.line("r.ReadMapElemKey()") // f("z.DecSendContainerState(codecSelferKcontainerMapKey%s)", x.xs)
+	// x.line(kName + "Slc = r.DecodeStringAsBytes()")
 	// let string be scoped to this loop alone, so it doesn't escape.
-	x.line(kName + " := string(" + kName + "Slc)")
-	x.linef("z.DecSendContainerState(codecSelfer_containerMapValue%s)", x.xs)
+	// x.line(kName + " := string(" + kName + "Slc)")
+	x.linef("%s := z.StringView(r.DecStructFieldKey(codecSelferValueType%s%s, z.DecScratchArrayBuffer()))",
+		kName, ti.keyType.String(), x.xs)
+	x.line("r.ReadMapElemValue()") // f("z.DecSendContainerState(codecSelferKcontainerMapValue%s)", x.xs)
 	x.decStructMapSwitch(kName, varname, rtid, t)
 
 	x.line("} // end for " + tpfx + "j" + i)
-	x.linef("z.DecSendContainerState(codecSelfer_containerMapEnd%s)", x.xs)
+	x.line("r.ReadMapEnd()") // f("z.DecSendContainerState(codecSelferKcontainerMapEnd%s)", x.xs)
 }
 
 func (x *genRunner) decStructArray(varname, lenvarname, breakString string, rtid uintptr, t reflect.Type) {
@@ -1501,18 +1547,19 @@ func (x *genRunner) decStructArray(varname, lenvarname, breakString string, rtid
 	x.linef("var %shl%s bool = %s >= 0", tpfx, i, lenvarname) // has length
 	for _, si := range tisfi {
 		var t2 reflect.StructField
-		if si.i != -1 {
-			t2 = t.Field(int(si.i))
-		} else {
+		{
 			//we must accommodate anonymous fields, where the embedded field is a nil pointer in the value.
 			// t2 = t.FieldByIndex(si.is)
 			t2typ := t
 			varname3 := varname
-			for _, ix := range si.is {
+			for ij, ix := range si.is {
+				if uint8(ij) == si.nis {
+					break
+				}
 				for t2typ.Kind() == reflect.Ptr {
 					t2typ = t2typ.Elem()
 				}
-				t2 = t2typ.Field(ix)
+				t2 = t2typ.Field(int(ix))
 				t2typ = t2.Type
 				varname3 = varname3 + "." + t2.Name
 				if t2typ.Kind() == reflect.Ptr {
@@ -1524,10 +1571,10 @@ func (x *genRunner) decStructArray(varname, lenvarname, breakString string, rtid
 		x.linef("%sj%s++; if %shl%s { %sb%s = %sj%s > %s } else { %sb%s = r.CheckBreak() }",
 			tpfx, i, tpfx, i, tpfx, i,
 			tpfx, i, lenvarname, tpfx, i)
-		x.linef("if %sb%s { z.DecSendContainerState(codecSelfer_containerArrayEnd%s); %s }",
-			tpfx, i, x.xs, breakString)
-		x.linef("z.DecSendContainerState(codecSelfer_containerArrayElem%s)", x.xs)
-		x.decVar(varname+"."+t2.Name, t2.Type, true)
+		x.linef("if %sb%s { r.ReadArrayEnd(); %s }", tpfx, i, breakString)
+		// x.linef("if %sb%s { z.DecSendContainerState(codecSelferKcontainerArrayEnd%s); %s }", tpfx, i, x.xs, breakString)
+		x.line("r.ReadArrayElem()") // f("z.DecSendContainerState(codecSelferKcontainerArrayElem%s)", x.xs)
+		x.decVar(varname+"."+t2.Name, "", t2.Type, true)
 	}
 	// read remaining values and throw away.
 	x.line("for {")
@@ -1535,10 +1582,10 @@ func (x *genRunner) decStructArray(varname, lenvarname, breakString string, rtid
 		tpfx, i, tpfx, i, tpfx, i,
 		tpfx, i, lenvarname, tpfx, i)
 	x.linef("if %sb%s { break }", tpfx, i)
-	x.linef("z.DecSendContainerState(codecSelfer_containerArrayElem%s)", x.xs)
+	x.line("r.ReadArrayElem()") // f("z.DecSendContainerState(codecSelferKcontainerArrayElem%s)", x.xs)
 	x.linef(`z.DecStructFieldNotFound(%sj%s - 1, "")`, tpfx, i)
 	x.line("}")
-	x.linef("z.DecSendContainerState(codecSelfer_containerArrayEnd%s)", x.xs)
+	x.line("r.ReadArrayEnd()") // f("z.DecSendContainerState(codecSelferKcontainerArrayEnd%s)", x.xs)
 }
 
 func (x *genRunner) decStruct(varname string, rtid uintptr, t reflect.Type) {
@@ -1548,7 +1595,7 @@ func (x *genRunner) decStruct(varname string, rtid uintptr, t reflect.Type) {
 	x.linef("if %sct%s == codecSelferValueTypeMap%s {", genTempVarPfx, i, x.xs)
 	x.line(genTempVarPfx + "l" + i + " := r.ReadMapStart()")
 	x.linef("if %sl%s == 0 {", genTempVarPfx, i)
-	x.linef("z.DecSendContainerState(codecSelfer_containerMapEnd%s)", x.xs)
+	x.line("r.ReadMapEnd()") // f("z.DecSendContainerState(codecSelferKcontainerMapEnd%s)", x.xs)
 	if genUseOneFunctionForDecStructMap {
 		x.line("} else { ")
 		x.linef("x.codecDecodeSelfFromMap(%sl%s, d)", genTempVarPfx, i)
@@ -1564,13 +1611,13 @@ func (x *genRunner) decStruct(varname string, rtid uintptr, t reflect.Type) {
 	x.linef("} else if %sct%s == codecSelferValueTypeArray%s {", genTempVarPfx, i, x.xs)
 	x.line(genTempVarPfx + "l" + i + " := r.ReadArrayStart()")
 	x.linef("if %sl%s == 0 {", genTempVarPfx, i)
-	x.linef("z.DecSendContainerState(codecSelfer_containerArrayEnd%s)", x.xs)
+	x.line("r.ReadArrayEnd()") // f("z.DecSendContainerState(codecSelferKcontainerArrayEnd%s)", x.xs)
 	x.line("} else { ")
 	x.linef("x.codecDecodeSelfFromArray(%sl%s, d)", genTempVarPfx, i)
 	x.line("}")
 	// else panic
 	x.line("} else { ")
-	x.line("panic(codecSelferOnlyMapOrArrayEncodeToStructErr" + x.xs + ")")
+	x.line("panic(errCodecSelferOnlyMapOrArrayEncodeToStruct" + x.xs + ")")
 	x.line("} ")
 }
 
@@ -1758,7 +1805,7 @@ type genInternal struct {
 
 func (x genInternal) FastpathLen() (l int) {
 	for _, v := range x.Values {
-		if v.Primitive == "" {
+		if v.Primitive == "" && !(v.MapKey == "" && v.Elem == "uint8") {
 			l++
 		}
 	}
@@ -1778,6 +1825,32 @@ func genInternalZeroValue(s string) string {
 	}
 }
 
+var genInternalNonZeroValueIdx [5]uint64
+var genInternalNonZeroValueStrs = [2][5]string{
+	{`"string-is-an-interface"`, "true", `"some-string"`, "11.1", "33"},
+	{`"string-is-an-interface-2"`, "true", `"some-string-2"`, "22.2", "44"},
+}
+
+func genInternalNonZeroValue(s string) string {
+	switch s {
+	case "interface{}", "interface {}":
+		genInternalNonZeroValueIdx[0]++
+		return genInternalNonZeroValueStrs[genInternalNonZeroValueIdx[0]%2][0] // return string, to remove ambiguity
+	case "bool":
+		genInternalNonZeroValueIdx[1]++
+		return genInternalNonZeroValueStrs[genInternalNonZeroValueIdx[1]%2][1]
+	case "string":
+		genInternalNonZeroValueIdx[2]++
+		return genInternalNonZeroValueStrs[genInternalNonZeroValueIdx[2]%2][2]
+	case "float32", "float64", "float", "double":
+		genInternalNonZeroValueIdx[3]++
+		return genInternalNonZeroValueStrs[genInternalNonZeroValueIdx[3]%2][3]
+	default:
+		genInternalNonZeroValueIdx[4]++
+		return genInternalNonZeroValueStrs[genInternalNonZeroValueIdx[4]%2][4]
+	}
+}
+
 func genInternalEncCommandAsString(s string, vname string) string {
 	switch s {
 	case "uint", "uint8", "uint16", "uint32", "uint64":
@@ -1785,7 +1858,7 @@ func genInternalEncCommandAsString(s string, vname string) string {
 	case "int", "int8", "int16", "int32", "int64":
 		return "ee.EncodeInt(int64(" + vname + "))"
 	case "string":
-		return "ee.EncodeString(c_UTF8, " + vname + ")"
+		return "ee.EncodeString(cUTF8, " + vname + ")"
 	case "float32":
 		return "ee.EncodeFloat32(" + vname + ")"
 	case "float64":
@@ -1827,9 +1900,9 @@ func genInternalDecCommandAsString(s string) string {
 	case "string":
 		return "dd.DecodeString()"
 	case "float32":
-		return "float32(dd.DecodeFloat(true))"
+		return "float32(chkFloat32(dd.DecodeFloat64()))"
 	case "float64":
-		return "dd.DecodeFloat(false)"
+		return "dd.DecodeFloat64()"
 	case "bool":
 		return "dd.DecodeBool()"
 	default:
@@ -1935,9 +2008,10 @@ func genInternalInit() {
 	// For each slice or map type, there must be a (symmetrical) Encode and Decode fast-path function
 	for _, s := range types {
 		gt.Values = append(gt.Values, genV{Primitive: s, Size: mapvaltypes2[s]})
-		if s != "uint8" { // do not generate fast path for slice of bytes. Treat specially already.
-			gt.Values = append(gt.Values, genV{Elem: s, Size: mapvaltypes2[s]})
-		}
+		// if s != "uint8" { // do not generate fast path for slice of bytes. Treat specially already.
+		// 	gt.Values = append(gt.Values, genV{Elem: s, Size: mapvaltypes2[s]})
+		// }
+		gt.Values = append(gt.Values, genV{Elem: s, Size: mapvaltypes2[s]})
 		if _, ok := mapvaltypes2[s]; !ok {
 			gt.Values = append(gt.Values, genV{MapKey: s, Elem: s, Size: 2 * mapvaltypes2[s]})
 		}
@@ -1951,6 +2025,7 @@ func genInternalInit() {
 	funcs["encmd"] = genInternalEncCommandAsString
 	funcs["decmd"] = genInternalDecCommandAsString
 	funcs["zerocmd"] = genInternalZeroValue
+	funcs["nonzerocmd"] = genInternalNonZeroValue
 	funcs["hasprefix"] = strings.HasPrefix
 	funcs["sorttype"] = genInternalSortType
 
diff --git a/vendor/github.com/ugorji/go/codec/helper.go b/vendor/github.com/ugorji/go/codec/helper.go
index 541256cb8..c6f4b9190 100644
--- a/vendor/github.com/ugorji/go/codec/helper.go
+++ b/vendor/github.com/ugorji/go/codec/helper.go
@@ -102,9 +102,12 @@ import (
 	"encoding/binary"
 	"errors"
 	"fmt"
+	"io"
 	"math"
+	"os"
 	"reflect"
 	"sort"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -112,32 +115,22 @@ import (
 
 const (
 	scratchByteArrayLen = 32
-	initCollectionCap   = 32 // 32 is defensive. 16 is preferred.
+	// initCollectionCap   = 16 // 32 is defensive. 16 is preferred.
 
 	// Support encoding.(Binary|Text)(Unm|M)arshaler.
 	// This constant flag will enable or disable it.
 	supportMarshalInterfaces = true
 
-	// Each Encoder or Decoder uses a cache of functions based on conditionals,
-	// so that the conditionals are not run every time.
-	//
-	// Either a map or a slice is used to keep track of the functions.
-	// The map is more natural, but has a higher cost than a slice/array.
-	// This flag (useMapForCodecCache) controls which is used.
-	//
-	// From benchmarks, slices with linear search perform better with < 32 entries.
-	// We have typically seen a high threshold of about 24 entries.
-	useMapForCodecCache = false
-
 	// for debugging, set this to false, to catch panic traces.
 	// Note that this will always cause rpc tests to fail, since they need io.EOF sent via panic.
 	recoverPanicToErr = true
 
-	// resetSliceElemToZeroValue: on decoding a slice, reset the element to a zero value first.
-	// concern: if the slice already contained some garbage, we will decode into that garbage.
-	// The chances of this are slim, so leave this "optimization".
-	// TODO: should this be true, to ensure that we always decode into a "zero" "empty" value?
-	resetSliceElemToZeroValue = false
+	// arrayCacheLen is the length of the cache used in encoder or decoder for
+	// allowing zero-alloc initialization.
+	arrayCacheLen = 8
+
+	// always set xDebug = false before releasing software
+	xDebug = true
 )
 
 var (
@@ -145,15 +138,36 @@ var (
 	zeroByteSlice = oneByteArr[:0:0]
 )
 
+var refBitset bitset32
+var pool pooler
+var panicv panicHdl
+
+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
+
+// const (
+// 	findCodecFnModeMap findCodecFnMode = iota
+// 	findCodecFnModeBinarySearch
+// 	findCodecFnModeLinearSearch
+// )
+
 type charEncoding uint8
 
 const (
-	c_RAW charEncoding = iota
-	c_UTF8
-	c_UTF16LE
-	c_UTF16BE
-	c_UTF32LE
-	c_UTF32BE
+	cRAW charEncoding = iota
+	cUTF8
+	cUTF16LE
+	cUTF16BE
+	cUTF32LE
+	cUTF32BE
 )
 
 // valueType is the stream type
@@ -171,12 +185,35 @@ const (
 	valueTypeBytes
 	valueTypeMap
 	valueTypeArray
-	valueTypeTimestamp
+	valueTypeTime
 	valueTypeExt
 
 	// valueTypeInvalid = 0xff
 )
 
+var valueTypeStrings = [...]string{
+	"Unset",
+	"Nil",
+	"Int",
+	"Uint",
+	"Float",
+	"Bool",
+	"String",
+	"Symbol",
+	"Bytes",
+	"Map",
+	"Array",
+	"Timestamp",
+	"Ext",
+}
+
+func (x valueType) String() string {
+	if int(x) < len(valueTypeStrings) {
+		return valueTypeStrings[x]
+	}
+	return strconv.FormatInt(int64(x), 10)
+}
+
 type seqType uint8
 
 const (
@@ -216,30 +253,26 @@ const rgetMaxRecursion = 2
 
 // Anecdotally, we believe most types have <= 12 fields.
 // Java's PMD rules set TooManyFields threshold to 15.
-const rgetPoolTArrayLen = 12
+const typeInfoLoadArrayLen = 12
 
-type rgetT struct {
+type typeInfoLoad struct {
 	fNames   []string
 	encNames []string
 	etypes   []uintptr
 	sfis     []*structFieldInfo
 }
 
-type rgetPoolT struct {
-	fNames   [rgetPoolTArrayLen]string
-	encNames [rgetPoolTArrayLen]string
-	etypes   [rgetPoolTArrayLen]uintptr
-	sfis     [rgetPoolTArrayLen]*structFieldInfo
-	sfiidx   [rgetPoolTArrayLen]sfiIdx
+type typeInfoLoadArray struct {
+	fNames   [typeInfoLoadArrayLen]string
+	encNames [typeInfoLoadArrayLen]string
+	etypes   [typeInfoLoadArrayLen]uintptr
+	sfis     [typeInfoLoadArrayLen]*structFieldInfo
+	sfiidx   [typeInfoLoadArrayLen]sfiIdx
 }
 
-var rgetPool = sync.Pool{
-	New: func() interface{} { return new(rgetPoolT) },
-}
-
-type containerStateRecv interface {
-	sendContainerState(containerState)
-}
+// type containerStateRecv interface {
+// 	sendContainerState(containerState)
+// }
 
 // mirror json.Marshaler and json.Unmarshaler here,
 // so we don't import the encoding/json package
@@ -265,6 +298,7 @@ var (
 	timeTyp       = reflect.TypeOf(time.Time{})
 	rawExtTyp     = reflect.TypeOf(RawExt{})
 	rawTyp        = reflect.TypeOf(Raw{})
+	uint8Typ      = reflect.TypeOf(uint8(0))
 	uint8SliceTyp = reflect.TypeOf([]uint8(nil))
 
 	mapBySliceTyp = reflect.TypeOf((*MapBySlice)(nil)).Elem()
@@ -280,6 +314,7 @@ var (
 
 	selferTyp = reflect.TypeOf((*Selfer)(nil)).Elem()
 
+	uint8TypId      = rt2id(uint8Typ)
 	uint8SliceTypId = rt2id(uint8SliceTyp)
 	rawExtTypId     = rt2id(rawExtTyp)
 	rawTypId        = rt2id(rawTyp)
@@ -300,27 +335,39 @@ var (
 
 	chkOvf checkOverflow
 
-	noFieldNameToStructFieldInfoErr = errors.New("no field name passed to parseStructFieldInfo")
+	errNoFieldNameToStructFieldInfo = errors.New("no field name passed to parseStructFieldInfo")
 )
 
 var defTypeInfos = NewTypeInfos([]string{"codec", "json"})
 
 var immutableKindsSet = [32]bool{
-	reflect.Int:     true,
-	reflect.Int8:    true,
-	reflect.Int16:   true,
-	reflect.Int32:   true,
-	reflect.Int64:   true,
-	reflect.Uint:    true,
-	reflect.Uint8:   true,
-	reflect.Uint16:  true,
-	reflect.Uint32:  true,
-	reflect.Uint64:  true,
-	reflect.Uintptr: true,
-	reflect.Float32: true,
-	reflect.Float64: true,
-	reflect.Bool:    true,
-	reflect.String:  true,
+	// reflect.Invalid:  ,
+	reflect.Bool:       true,
+	reflect.Int:        true,
+	reflect.Int8:       true,
+	reflect.Int16:      true,
+	reflect.Int32:      true,
+	reflect.Int64:      true,
+	reflect.Uint:       true,
+	reflect.Uint8:      true,
+	reflect.Uint16:     true,
+	reflect.Uint32:     true,
+	reflect.Uint64:     true,
+	reflect.Uintptr:    true,
+	reflect.Float32:    true,
+	reflect.Float64:    true,
+	reflect.Complex64:  true,
+	reflect.Complex128: true,
+	// reflect.Array
+	// reflect.Chan
+	// reflect.Func: true,
+	// reflect.Interface
+	// reflect.Map
+	// reflect.Ptr
+	// reflect.Slice
+	reflect.String: true,
+	// reflect.Struct
+	// reflect.UnsafePointer
 }
 
 // Selfer defines methods by which a value can encode or decode itself.
@@ -333,20 +380,30 @@ type Selfer interface {
 	CodecDecodeSelf(*Decoder)
 }
 
-// MapBySlice represents a slice which should be encoded as a map in the stream.
+// MapBySlice is a tag interface that denotes a slice which should be encoded as a map in the stream.
 // The slice contains a sequence of key-value pairs.
 // This affords storing a map in a specific sequence in the stream.
 //
+// Example usage:
+//    type T1 []string         // or []int or []Point or any other "slice" type
+//    func (_ T1) MapBySlice{} // T1 now implements MapBySlice, and will be encoded as a map
+//    type T2 struct { KeyValues T1 }
+//
+//    var kvs = []string{"one", "1", "two", "2", "three", "3"}
+//    var v2 = T2{ KeyValues: T1(kvs) }
+//    // v2 will be encoded like the map: {"KeyValues": {"one": "1", "two": "2", "three": "3"} }
+//
 // The support of MapBySlice affords the following:
 //   - A slice type which implements MapBySlice will be encoded as a map
 //   - A slice can be decoded from a map in the stream
+//   - It MUST be a slice type (not a pointer receiver) that implements MapBySlice
 type MapBySlice interface {
 	MapBySlice()
 }
 
-// WARNING: DO NOT USE DIRECTLY. EXPORTED FOR GODOC BENEFIT. WILL BE REMOVED.
-//
 // BasicHandle encapsulates the common options and extension functions.
+//
+// Deprecated: DO NOT USE DIRECTLY. EXPORTED FOR GODOC BENEFIT. WILL BE REMOVED.
 type BasicHandle struct {
 	// TypeInfos is used to get the type info for any type.
 	//
@@ -356,8 +413,19 @@ type BasicHandle struct {
 	extHandle
 	EncodeOptions
 	DecodeOptions
+	RPCOptions
+	noBuiltInTypeChecker
 }
 
+// func (x *BasicHandle) postCopy() {
+// 	if len(x.extHandle) == 0 {
+// 		return
+// 	}
+// 	v := make(extHandle, len(x.extHandle))
+// 	copy(v, x.extHandle)
+// 	x.extHandle = v
+// }
+
 func (x *BasicHandle) getBasicHandle() *BasicHandle {
 	return x
 }
@@ -375,14 +443,44 @@ func (x *BasicHandle) getTypeInfo(rtid uintptr, rt reflect.Type) (pti *typeInfo)
 // and not modified while in use. Such a pre-configured Handle
 // is safe for concurrent access.
 type Handle interface {
+	Name() string
 	getBasicHandle() *BasicHandle
 	newEncDriver(w *Encoder) encDriver
 	newDecDriver(r *Decoder) decDriver
 	isBinary() bool
+	hasElemSeparators() bool
+	IsBuiltinType(rtid uintptr) bool
 }
 
+// func copyHandle(h Handle) (h2 Handle) {
+// 	_ = h.getBasicHandle().postCopy // ensure postCopy function on basicHandle isn't commented
+// 	switch hh := h.(type) {
+// 	case *JsonHandle:
+// 		hh2 := *hh
+// 		hh2.postCopy()
+// 		h2 = &hh2
+// 	case *SimpleHandle:
+// 		hh2 := *hh
+// 		hh2.postCopy()
+// 		h2 = &hh2
+// 	case *CborHandle:
+// 		hh2 := *hh
+// 		hh2.postCopy()
+// 		h2 = &hh2
+// 	case *MsgpackHandle:
+// 		hh2 := *hh
+// 		hh2.postCopy()
+// 		h2 = &hh2
+// 	case *BincHandle:
+// 		hh2 := *hh
+// 		hh2.postCopy()
+// 		h2 = &hh2
+// 	}
+// 	return
+// }
+
 // Raw represents raw formatted bytes.
-// We "blindly" store it during encode and store the raw bytes during decode.
+// We "blindly" store it during encode and retrieve the raw bytes during decode.
 // Note: it is dangerous during encode, so we may gate the behaviour behind an Encode flag which must be explicitly set.
 type Raw []byte
 
@@ -465,56 +563,58 @@ type setExtWrapper struct {
 	i InterfaceExt
 }
 
-func (x *setExtWrapper) WriteExt(v interface{}) []byte {
-	if x.b == nil {
-		panic("BytesExt.WriteExt is not supported")
+func (x *setExtWrapper) check(v bool, s string) {
+	if v {
+		panic(fmt.Errorf("%s is not supported", s))
 	}
+}
+func (x *setExtWrapper) WriteExt(v interface{}) []byte {
+	x.check(x.b == nil, "BytesExt.WriteExt")
 	return x.b.WriteExt(v)
 }
 
 func (x *setExtWrapper) ReadExt(v interface{}, bs []byte) {
-	if x.b == nil {
-		panic("BytesExt.WriteExt is not supported")
-
-	}
+	x.check(x.b == nil, "BytesExt.ReadExt")
 	x.b.ReadExt(v, bs)
 }
 
 func (x *setExtWrapper) ConvertExt(v interface{}) interface{} {
-	if x.i == nil {
-		panic("InterfaceExt.ConvertExt is not supported")
-
-	}
+	x.check(x.i == nil, "InterfaceExt.ConvertExt")
 	return x.i.ConvertExt(v)
 }
 
 func (x *setExtWrapper) UpdateExt(dest interface{}, v interface{}) {
-	if x.i == nil {
-		panic("InterfaceExxt.UpdateExt is not supported")
-
-	}
+	x.check(x.i == nil, "InterfaceExt.UpdateExt")
 	x.i.UpdateExt(dest, v)
 }
 
 type binaryEncodingType struct{}
 
-func (_ binaryEncodingType) isBinary() bool { return true }
+func (binaryEncodingType) isBinary() bool { return true }
 
 type textEncodingType struct{}
 
-func (_ textEncodingType) isBinary() bool { return false }
+func (textEncodingType) isBinary() bool { return false }
 
 // noBuiltInTypes is embedded into many types which do not support builtins
 // e.g. msgpack, simple, cbor.
-type noBuiltInTypes struct{}
 
-func (_ noBuiltInTypes) IsBuiltinType(rt uintptr) bool           { return false }
-func (_ noBuiltInTypes) EncodeBuiltin(rt uintptr, v interface{}) {}
-func (_ noBuiltInTypes) DecodeBuiltin(rt uintptr, v interface{}) {}
+type noBuiltInTypeChecker struct{}
 
-type noStreamingCodec struct{}
+func (noBuiltInTypeChecker) IsBuiltinType(rt uintptr) bool { return false }
 
-func (_ noStreamingCodec) CheckBreak() bool { return false }
+type noBuiltInTypes struct{ noBuiltInTypeChecker }
+
+func (noBuiltInTypes) EncodeBuiltin(rt uintptr, v interface{}) {}
+func (noBuiltInTypes) DecodeBuiltin(rt uintptr, v interface{}) {}
+
+// type noStreamingCodec struct{}
+// func (noStreamingCodec) CheckBreak() bool { return false }
+// func (noStreamingCodec) hasElemSeparators() bool { return false }
+
+type noElemSeparators struct{}
+
+func (noElemSeparators) hasElemSeparators() (v bool) { return }
 
 // bigenHelper.
 // Users must already slice the x completely, because we will not reslice.
@@ -539,19 +639,20 @@ func (z bigenHelper) writeUint64(v uint64) {
 }
 
 type extTypeTagFn struct {
-	rtid uintptr
-	rt   reflect.Type
-	tag  uint64
-	ext  Ext
+	rtid    uintptr
+	rtidptr uintptr
+	rt      reflect.Type
+	tag     uint64
+	ext     Ext
 }
 
 type extHandle []extTypeTagFn
 
-// DEPRECATED: Use SetBytesExt or SetInterfaceExt on the Handle instead.
-//
 // AddExt registes an encode and decode function for a reflect.Type.
 // AddExt internally calls SetExt.
 // To deregister an Ext, call AddExt with nil encfn and/or nil decfn.
+//
+// Deprecated: Use SetBytesExt or SetInterfaceExt on the Handle instead.
 func (o *extHandle) AddExt(
 	rt reflect.Type, tag byte,
 	encfn func(reflect.Value) ([]byte, error), decfn func(reflect.Value, []byte) error,
@@ -562,32 +663,44 @@ func (o *extHandle) AddExt(
 	return o.SetExt(rt, uint64(tag), addExtWrapper{encfn, decfn})
 }
 
-// DEPRECATED: Use SetBytesExt or SetInterfaceExt on the Handle instead.
-//
 // Note that the type must be a named type, and specifically not
 // a pointer or Interface. An error is returned if that is not honored.
+// To Deregister an ext, call SetExt with nil Ext.
 //
-// To Deregister an ext, call SetExt with nil Ext
+// Deprecated: Use SetBytesExt or SetInterfaceExt on the Handle instead.
 func (o *extHandle) SetExt(rt reflect.Type, tag uint64, ext Ext) (err error) {
 	// o is a pointer, because we may need to initialize it
-	if rt.PkgPath() == "" || rt.Kind() == reflect.Interface {
-		err = fmt.Errorf("codec.Handle.AddExt: Takes named type, not a pointer or interface: %T",
-			reflect.Zero(rt).Interface())
-		return
+	rk := rt.Kind()
+	for rk == reflect.Ptr {
+		rt = rt.Elem()
+		rk = rt.Kind()
+	}
+
+	if rt.PkgPath() == "" || rk == reflect.Interface { // || rk == reflect.Ptr {
+		return fmt.Errorf("codec.Handle.SetExt: Takes named type, not a pointer or interface: %v", rt)
 	}
 
 	rtid := rt2id(rt)
-	for _, v := range *o {
-		if v.rtid == rtid {
-			v.tag, v.ext = tag, ext
-			return
+	switch rtid {
+	case timeTypId, rawTypId, rawExtTypId:
+		// all natively supported type, so cannot have an extension
+		return // TODO: should we silently ignore, or return an error???
+	}
+	o2 := *o
+	if o2 == nil {
+		o2 = make([]extTypeTagFn, 0, 4)
+		*o = o2
+	} else {
+		for i := range o2 {
+			v := &o2[i]
+			if v.rtid == rtid {
+				v.tag, v.ext = tag, ext
+				return
+			}
 		}
 	}
-
-	if *o == nil {
-		*o = make([]extTypeTagFn, 0, 4)
-	}
-	*o = append(*o, extTypeTagFn{rtid, rt, tag, ext})
+	rtidptr := rt2id(reflect.PtrTo(rt))
+	*o = append(o2, extTypeTagFn{rtid, rtidptr, rt, tag, ext})
 	return
 }
 
@@ -595,7 +708,7 @@ func (o extHandle) getExt(rtid uintptr) *extTypeTagFn {
 	var v *extTypeTagFn
 	for i := range o {
 		v = &o[i]
-		if v.rtid == rtid {
+		if v.rtid == rtid || v.rtidptr == rtid {
 			return v
 		}
 	}
@@ -613,91 +726,100 @@ func (o extHandle) getExtForTag(tag uint64) *extTypeTagFn {
 	return nil
 }
 
+const maxLevelsEmbedding = 16
+
 type structFieldInfo struct {
 	encName   string // encode name
 	fieldName string // field name
 
-	// only one of 'i' or 'is' can be set. If 'i' is -1, then 'is' has been set.
-
-	is        []int // (recursive/embedded) field index in struct
-	i         int16 // field index in struct
+	is        [maxLevelsEmbedding]uint16 // (recursive/embedded) field index in struct
+	nis       uint8                      // num levels of embedding. if 1, then it's not embedded.
 	omitEmpty bool
-	toArray   bool // if field is _struct, is the toArray set?
-}
-
-// func (si *structFieldInfo) isZero() bool {
-// 	return si.encName == "" && len(si.is) == 0 && si.i == 0 && !si.omitEmpty && !si.toArray
-// }
-
-// rv returns the field of the struct.
-// If anonymous, it returns an Invalid
-func (si *structFieldInfo) field(v reflect.Value, update bool) (rv2 reflect.Value) {
-	if si.i != -1 {
-		v = v.Field(int(si.i))
-		return v
-	}
-	// replicate FieldByIndex
-	for _, x := range si.is {
-		for v.Kind() == reflect.Ptr {
-			if v.IsNil() {
-				if !update {
-					return
-				}
-				v.Set(reflect.New(v.Type().Elem()))
-			}
-			v = v.Elem()
-		}
-		v = v.Field(x)
-	}
-	return v
+	// toArray   bool // if field is _struct, is the toArray set?
 }
 
 func (si *structFieldInfo) setToZeroValue(v reflect.Value) {
-	if si.i != -1 {
-		v = v.Field(int(si.i))
-		v.Set(reflect.Zero(v.Type()))
-		// v.Set(reflect.New(v.Type()).Elem())
-		// v.Set(reflect.New(v.Type()))
-	} else {
-		// replicate FieldByIndex
-		for _, x := range si.is {
-			for v.Kind() == reflect.Ptr {
-				if v.IsNil() {
-					return
-				}
-				v = v.Elem()
-			}
-			v = v.Field(x)
-		}
+	if v, valid := si.field(v, false); valid {
 		v.Set(reflect.Zero(v.Type()))
 	}
 }
 
-func parseStructFieldInfo(fname string, stag string) *structFieldInfo {
-	// if fname == "" {
-	// 	panic(noFieldNameToStructFieldInfoErr)
-	// }
-	si := structFieldInfo{
-		encName: fname,
+// rv returns the field of the struct.
+// If anonymous, it returns an Invalid
+func (si *structFieldInfo) field(v reflect.Value, update bool) (rv2 reflect.Value, valid bool) {
+	// replicate FieldByIndex
+	for i, x := range si.is {
+		if uint8(i) == si.nis {
+			break
+		}
+		if v, valid = baseStructRv(v, update); !valid {
+			return
+		}
+		v = v.Field(int(x))
 	}
 
-	if stag != "" {
-		for i, s := range strings.Split(stag, ",") {
-			if i == 0 {
-				if s != "" {
-					si.encName = s
-				}
-			} else {
-				if s == "omitempty" {
-					si.omitEmpty = true
-				} else if s == "toarray" {
-					si.toArray = true
-				}
+	return v, true
+}
+
+// func (si *structFieldInfo) fieldval(v reflect.Value, update bool) reflect.Value {
+// 	v, _ = si.field(v, update)
+// 	return v
+// }
+
+func parseStructInfo(stag string) (toArray, omitEmpty bool, keytype valueType) {
+	keytype = valueTypeString // default
+	if stag == "" {
+		return
+	}
+	for i, s := range strings.Split(stag, ",") {
+		if i == 0 {
+		} else {
+			switch s {
+			case "omitempty":
+				omitEmpty = true
+			case "toarray":
+				toArray = true
+			case "int":
+				keytype = valueTypeInt
+			case "uint":
+				keytype = valueTypeUint
+			case "float":
+				keytype = valueTypeFloat
+				// case "bool":
+				// 	keytype = valueTypeBool
+			case "string":
+				keytype = valueTypeString
+			}
+		}
+	}
+	return
+}
+
+func parseStructFieldInfo(fname string, stag string) (si *structFieldInfo) {
+	// if fname == "" {
+	// 	panic(errNoFieldNameToStructFieldInfo)
+	// }
+	si = &structFieldInfo{encName: fname}
+
+	if stag == "" {
+		return
+	}
+	for i, s := range strings.Split(stag, ",") {
+		if i == 0 {
+			if s != "" {
+				si.encName = s
+			}
+		} else {
+			switch s {
+			case "omitempty":
+				si.omitEmpty = true
+				// case "toarray":
+				// 	si.toArray = true
 			}
 		}
 	}
 	// si.encNameBs = []byte(si.encName)
-	return &si
+	return
 }
 
 type sfiSortedByEncName []*structFieldInfo
@@ -714,7 +836,98 @@ func (p sfiSortedByEncName) Swap(i, j int) {
 	p[i], p[j] = p[j], p[i]
 }
 
-// typeInfo keeps information about each type referenced in the encode/decode sequence.
+const structFieldNodeNumToCache = 4
+
+type structFieldNodeCache struct {
+	rv  [structFieldNodeNumToCache]reflect.Value
+	idx [structFieldNodeNumToCache]uint32
+	num uint8
+}
+
+func (x *structFieldNodeCache) get(key uint32) (fv reflect.Value, valid bool) {
+	// defer func() { fmt.Printf(">>>> found in cache2? %v\n", valid) }()
+	for i, k := range &x.idx {
+		if uint8(i) == x.num {
+			return // break
+		}
+		if key == k {
+			return x.rv[i], true
+		}
+	}
+	return
+}
+
+func (x *structFieldNodeCache) tryAdd(fv reflect.Value, key uint32) {
+	if x.num < structFieldNodeNumToCache {
+		x.rv[x.num] = fv
+		x.idx[x.num] = key
+		x.num++
+		return
+	}
+}
+
+type structFieldNode struct {
+	v      reflect.Value
+	cache2 structFieldNodeCache
+	cache3 structFieldNodeCache
+	update bool
+}
+
+func (x *structFieldNode) field(si *structFieldInfo) (fv reflect.Value) {
+	// return si.fieldval(x.v, x.update)
+	// Note: we only cache if nis=2 or nis=3 i.e. up to 2 levels of embedding
+	// This mostly saves us time on the repeated calls to v.Elem, v.Field, etc.
+	var valid bool
+	switch si.nis {
+	case 1:
+		fv = x.v.Field(int(si.is[0]))
+	case 2:
+		if fv, valid = x.cache2.get(uint32(si.is[0])); valid {
+			fv = fv.Field(int(si.is[1]))
+			return
+		}
+		fv = x.v.Field(int(si.is[0]))
+		if fv, valid = baseStructRv(fv, x.update); !valid {
+			return
+		}
+		x.cache2.tryAdd(fv, uint32(si.is[0]))
+		fv = fv.Field(int(si.is[1]))
+	case 3:
+		var key uint32 = uint32(si.is[0])<<16 | uint32(si.is[1])
+		if fv, valid = x.cache3.get(key); valid {
+			fv = fv.Field(int(si.is[2]))
+			return
+		}
+		fv = x.v.Field(int(si.is[0]))
+		if fv, valid = baseStructRv(fv, x.update); !valid {
+			return
+		}
+		fv = fv.Field(int(si.is[1]))
+		if fv, valid = baseStructRv(fv, x.update); !valid {
+			return
+		}
+		x.cache3.tryAdd(fv, key)
+		fv = fv.Field(int(si.is[2]))
+	default:
+		fv, _ = si.field(x.v, x.update)
+	}
+	return
+}
+
+func baseStructRv(v reflect.Value, update bool) (v2 reflect.Value, valid bool) {
+	for v.Kind() == reflect.Ptr {
+		if v.IsNil() {
+			if !update {
+				return
+			}
+			v.Set(reflect.New(v.Type().Elem()))
+		}
+		v = v.Elem()
+	}
+	return v, true
+}
+
+// typeInfo keeps information about each (non-ptr) type referenced in the encode/decode sequence.
 //
 // During an encode/decode sequence, we work as below:
 //   - If base is a built in type, en/decode base value
@@ -732,43 +945,41 @@ type typeInfo struct {
 
 	numMeth uint16 // number of methods
 
-	// baseId gives pointer to the base reflect.Type, after deferencing
-	// the pointers. E.g. base type of ***time.Time is time.Time.
-	base      reflect.Type
-	baseId    uintptr
-	baseIndir int8 // number of indirections to get to base
+	anyOmitEmpty bool
 
 	mbs bool // base type (T or *T) is a MapBySlice
 
-	bm        bool // base type (T or *T) is a binaryMarshaler
-	bunm      bool // base type (T or *T) is a binaryUnmarshaler
-	bmIndir   int8 // number of indirections to get to binaryMarshaler type
-	bunmIndir int8 // number of indirections to get to binaryUnmarshaler type
+	// format of marshal type fields below: [btj][mu]p? OR csp?
 
-	tm        bool // base type (T or *T) is a textMarshaler
-	tunm      bool // base type (T or *T) is a textUnmarshaler
-	tmIndir   int8 // number of indirections to get to textMarshaler type
-	tunmIndir int8 // number of indirections to get to textUnmarshaler type
+	bm  bool // T is a binaryMarshaler
+	bmp bool // *T is a binaryMarshaler
+	bu  bool // T is a binaryUnmarshaler
+	bup bool // *T is a binaryUnmarshaler
+	tm  bool // T is a textMarshaler
+	tmp bool // *T is a textMarshaler
+	tu  bool // T is a textUnmarshaler
+	tup bool // *T is a textUnmarshaler
+	jm  bool // T is a jsonMarshaler
+	jmp bool // *T is a jsonMarshaler
+	ju  bool // T is a jsonUnmarshaler
+	jup bool // *T is a jsonUnmarshaler
+	cs  bool // T is a Selfer
+	csp bool // *T is a Selfer
 
-	jm        bool // base type (T or *T) is a jsonMarshaler
-	junm      bool // base type (T or *T) is a jsonUnmarshaler
-	jmIndir   int8 // number of indirections to get to jsonMarshaler type
-	junmIndir int8 // number of indirections to get to jsonUnmarshaler type
-
-	cs      bool // base type (T or *T) is a Selfer
-	csIndir int8 // number of indirections to get to Selfer type
-
-	toArray bool // whether this (struct) type should be encoded as an array
+	toArray bool      // whether this (struct) type should be encoded as an array
+	keyType valueType // what type of key: default is string
 }
 
-// linear search. faster than binary search in my testing up to 16-field structs.
-const binarySearchThreshold = 8 // similar to what python does for hashtables
+// define length beyond which we do a binary search instead of a linear search.
+// From our testing, linear search seems faster than binary search up to 16-field structs.
+// However, we set to 8 similar to what python does for hashtables.
+const indexForEncNameBinarySearchThreshold = 8
 
 func (ti *typeInfo) indexForEncName(name string) int {
 	// NOTE: name may be a stringView, so don't pass it to another function.
 	//tisfi := ti.sfi
 	sfilen := len(ti.sfi)
-	if sfilen < binarySearchThreshold {
+	if sfilen < indexForEncNameBinarySearchThreshold {
 		for i, si := range ti.sfi {
 			if si.encName == name {
 				return i
@@ -829,7 +1040,6 @@ func (x *TypeInfos) structTag(t reflect.StructTag) (s string) {
 
 func (x *TypeInfos) find(sp *[]rtid2ti, rtid uintptr) (idx int, ti *typeInfo) {
 	// binary search. adapted from sort/search.go.
-	// fmt.Printf(">>>> calling typeinfos.find ... \n")
 	// if sp == nil {
 	// 	return -1, nil
 	// }
@@ -850,7 +1060,6 @@ func (x *TypeInfos) find(sp *[]rtid2ti, rtid uintptr) (idx int, ti *typeInfo) {
 }
 
 func (x *TypeInfos) get(rtid uintptr, rt reflect.Type) (pti *typeInfo) {
-	// fmt.Printf(">>>> calling typeinfos.get ... \n")
 	sp := x.infos.load()
 	var idx int
 	if sp != nil {
@@ -860,69 +1069,44 @@ func (x *TypeInfos) get(rtid uintptr, rt reflect.Type) (pti *typeInfo) {
 		}
 	}
 
+	rk := rt.Kind()
+
+	if rk == reflect.Ptr { // || (rk == reflect.Interface && rtid != intfTypId) {
+		panic(fmt.Errorf("invalid kind passed to TypeInfos.get: %v - %v", rk, rt))
+	}
+
 	// do not hold lock while computing this.
 	// it may lead to duplication, but that's ok.
 	ti := typeInfo{rt: rt, rtid: rtid}
 	// ti.rv0 = reflect.Zero(rt)
 
 	ti.numMeth = uint16(rt.NumMethod())
-	var ok bool
-	var indir int8
-	if ok, indir = implementsIntf(rt, binaryMarshalerTyp); ok {
-		ti.bm, ti.bmIndir = true, indir
-	}
-	if ok, indir = implementsIntf(rt, binaryUnmarshalerTyp); ok {
-		ti.bunm, ti.bunmIndir = true, indir
-	}
-	if ok, indir = implementsIntf(rt, textMarshalerTyp); ok {
-		ti.tm, ti.tmIndir = true, indir
-	}
-	if ok, indir = implementsIntf(rt, textUnmarshalerTyp); ok {
-		ti.tunm, ti.tunmIndir = true, indir
-	}
-	if ok, indir = implementsIntf(rt, jsonMarshalerTyp); ok {
-		ti.jm, ti.jmIndir = true, indir
-	}
-	if ok, indir = implementsIntf(rt, jsonUnmarshalerTyp); ok {
-		ti.junm, ti.junmIndir = true, indir
-	}
-	if ok, indir = implementsIntf(rt, selferTyp); ok {
-		ti.cs, ti.csIndir = true, indir
-	}
-	if ok, _ = implementsIntf(rt, mapBySliceTyp); ok {
-		ti.mbs = true
+
+	ti.bm, ti.bmp = implIntf(rt, binaryMarshalerTyp)
+	ti.bu, ti.bup = implIntf(rt, binaryUnmarshalerTyp)
+	ti.tm, ti.tmp = implIntf(rt, textMarshalerTyp)
+	ti.tu, ti.tup = implIntf(rt, textUnmarshalerTyp)
+	ti.jm, ti.jmp = implIntf(rt, jsonMarshalerTyp)
+	ti.ju, ti.jup = implIntf(rt, jsonUnmarshalerTyp)
+	ti.cs, ti.csp = implIntf(rt, selferTyp)
+	if rt.Kind() == reflect.Slice {
+		ti.mbs, _ = implIntf(rt, mapBySliceTyp)
 	}
 
-	pt := rt
-	var ptIndir int8
-	// for ; pt.Kind() == reflect.Ptr; pt, ptIndir = pt.Elem(), ptIndir+1 { }
-	for pt.Kind() == reflect.Ptr {
-		pt = pt.Elem()
-		ptIndir++
-	}
-	if ptIndir == 0 {
-		ti.base = rt
-		ti.baseId = rtid
-	} else {
-		ti.base = pt
-		ti.baseId = rt2id(pt)
-		ti.baseIndir = ptIndir
-	}
-
-	if rt.Kind() == reflect.Struct {
+	if rk == reflect.Struct {
 		var omitEmpty bool
 		if f, ok := rt.FieldByName(structInfoFieldName); ok {
-			siInfo := parseStructFieldInfo(structInfoFieldName, x.structTag(f.Tag))
-			ti.toArray = siInfo.toArray
-			omitEmpty = siInfo.omitEmpty
+			ti.toArray, omitEmpty, ti.keyType = parseStructInfo(x.structTag(f.Tag))
+		} else {
+			ti.keyType = valueTypeString
 		}
-		pi := rgetPool.Get()
-		pv := pi.(*rgetPoolT)
-		pv.etypes[0] = ti.baseId
-		vv := rgetT{pv.fNames[:0], pv.encNames[:0], pv.etypes[:1], pv.sfis[:0]}
+		pp, pi := pool.tiLoad()
+		pv := pi.(*typeInfoLoadArray)
+		pv.etypes[0] = ti.rtid
+		vv := typeInfoLoad{pv.fNames[:0], pv.encNames[:0], pv.etypes[:1], pv.sfis[:0]}
 		x.rget(rt, rtid, omitEmpty, nil, &vv)
-		ti.sfip, ti.sfi = rgetResolveSFI(vv.sfis, pv.sfiidx[:0])
-		rgetPool.Put(pi)
+		ti.sfip, ti.sfi, ti.anyOmitEmpty = rgetResolveSFI(vv.sfis, pv.sfiidx[:0])
+		pp.Put(pi)
 	}
 	// sfi = sfip
 
@@ -930,7 +1114,6 @@ func (x *TypeInfos) get(rtid uintptr, rt reflect.Type) (pti *typeInfo) {
 	x.mu.Lock()
 	sp = x.infos.load()
 	if sp == nil {
-		// fmt.Printf(">>>> in typeinfos.get: sp == nil\n")
 		pti = &ti
 		vs = []rtid2ti{{rtid, pti}}
 		x.infos.store(&vs)
@@ -947,12 +1130,11 @@ func (x *TypeInfos) get(rtid uintptr, rt reflect.Type) (pti *typeInfo) {
 		}
 	}
 	x.mu.Unlock()
-	// fmt.Printf(">>>>>>> TypeInfos: Num Elements: %v\n", len(*(x.infos.load())))
 	return
 }
 
 func (x *TypeInfos) rget(rt reflect.Type, rtid uintptr, omitEmpty bool,
-	indexstack []int, pv *rgetT,
+	indexstack []uint16, pv *typeInfoLoad,
 ) {
 	// Read up fields and store how to access the value.
 	//
@@ -962,10 +1144,13 @@ func (x *TypeInfos) rget(rt reflect.Type, rtid uintptr, omitEmpty bool,
 	// Note: we consciously use slices, not a map, to simulate a set.
 	//       Typically, types have < 16 fields,
 	//       and iteration using equals is faster than maps there
-
+	flen := rt.NumField()
+	if flen > (1<<maxLevelsEmbedding - 1) {
+		panic(fmt.Errorf("codec: types with more than %v fields are not supported - has %v fields", (1<<maxLevelsEmbedding - 1), flen))
+	}
 LOOP:
-	for j, jlen := 0, rt.NumField(); j < jlen; j++ {
-		f := rt.Field(j)
+	for j, jlen := uint16(0), uint16(flen); j < jlen; j++ {
+		f := rt.Field(int(j))
 		fkind := f.Type.Kind()
 		// skip if a func type, or is unexported, or structTag value == "-"
 		switch fkind {
@@ -973,9 +1158,8 @@ LOOP:
 			continue LOOP
 		}
 
-		// if r1, _ := utf8.DecodeRuneInString(f.Name);
-		// r1 == utf8.RuneError || !unicode.IsUpper(r1) {
-		if f.PkgPath != "" && !f.Anonymous { // unexported, not embedded
+		isUnexported := f.PkgPath != ""
+		if isUnexported && !f.Anonymous {
 			continue
 		}
 		stag := x.structTag(f.Tag)
@@ -986,55 +1170,64 @@ LOOP:
 		// if anonymous and no struct tag (or it's blank),
 		// and a struct (or pointer to struct), inline it.
 		if f.Anonymous && fkind != reflect.Interface {
+			// ^^ redundant but ok: per go spec, an embedded pointer type cannot be to an interface
+			ft := f.Type
+			isPtr := ft.Kind() == reflect.Ptr
+			for ft.Kind() == reflect.Ptr {
+				ft = ft.Elem()
+			}
+			isStruct := ft.Kind() == reflect.Struct
+
+			// Ignore embedded fields of unexported non-struct types.
+			// Also, from go1.10, ignore pointers to unexported struct types
+			// because unmarshal cannot assign a new struct to an unexported field.
+			// See https://golang.org/issue/21357
+			if (isUnexported && !isStruct) || (!allowSetUnexportedEmbeddedPtr && isUnexported && isPtr) {
+				continue
+			}
 			doInline := stag == ""
 			if !doInline {
 				si = parseStructFieldInfo("", stag)
 				doInline = si.encName == ""
 				// doInline = si.isZero()
 			}
-			if doInline {
-				ft := f.Type
-				for ft.Kind() == reflect.Ptr {
-					ft = ft.Elem()
-				}
-				if ft.Kind() == reflect.Struct {
-					// if etypes contains this, don't call rget again (as fields are already seen here)
-					ftid := rt2id(ft)
-					// We cannot recurse forever, but we need to track other field depths.
-					// So - we break if we see a type twice (not the first time).
-					// This should be sufficient to handle an embedded type that refers to its
-					// owning type, which then refers to its embedded type.
-					processIt := true
-					numk := 0
-					for _, k := range pv.etypes {
-						if k == ftid {
-							numk++
-							if numk == rgetMaxRecursion {
-								processIt = false
-								break
-							}
+			if doInline && isStruct {
+				// if etypes contains this, don't call rget again (as fields are already seen here)
+				ftid := rt2id(ft)
+				// We cannot recurse forever, but we need to track other field depths.
+				// So - we break if we see a type twice (not the first time).
+				// This should be sufficient to handle an embedded type that refers to its
+				// owning type, which then refers to its embedded type.
+				processIt := true
+				numk := 0
+				for _, k := range pv.etypes {
+					if k == ftid {
+						numk++
+						if numk == rgetMaxRecursion {
+							processIt = false
+							break
 						}
 					}
-					if processIt {
-						pv.etypes = append(pv.etypes, ftid)
-						indexstack2 := make([]int, len(indexstack)+1)
-						copy(indexstack2, indexstack)
-						indexstack2[len(indexstack)] = j
-						// indexstack2 := append(append(make([]int, 0, len(indexstack)+4), indexstack...), j)
-						x.rget(ft, ftid, omitEmpty, indexstack2, pv)
-					}
-					continue
 				}
+				if processIt {
+					pv.etypes = append(pv.etypes, ftid)
+					indexstack2 := make([]uint16, len(indexstack)+1)
+					copy(indexstack2, indexstack)
+					indexstack2[len(indexstack)] = j
+					// indexstack2 := append(append(make([]int, 0, len(indexstack)+4), indexstack...), j)
+					x.rget(ft, ftid, omitEmpty, indexstack2, pv)
+				}
+				continue
 			}
 		}
 
 		// after the anonymous dance: if an unexported field, skip
-		if f.PkgPath != "" { // unexported
+		if isUnexported {
 			continue
 		}
 
 		if f.Name == "" {
-			panic(noFieldNameToStructFieldInfoErr)
+			panic(errNoFieldNameToStructFieldInfo)
 		}
 
 		pv.fNames = append(pv.fNames, f.Name)
@@ -1049,15 +1242,12 @@ LOOP:
 		pv.encNames = append(pv.encNames, si.encName)
 
 		// si.ikind = int(f.Type.Kind())
-		if len(indexstack) == 0 {
-			si.i = int16(j)
-		} else {
-			si.i = -1
-			si.is = make([]int, len(indexstack)+1)
-			copy(si.is, indexstack)
-			si.is[len(indexstack)] = j
-			// si.is = append(append(make([]int, 0, len(indexstack)+4), indexstack...), j)
+		if len(indexstack) > maxLevelsEmbedding-1 {
+			panic(fmt.Errorf("codec: only supports up to %v depth of embedding - type has %v depth", maxLevelsEmbedding-1, len(indexstack)))
 		}
+		si.nis = uint8(len(indexstack)) + 1
+		copy(si.is[:], indexstack)
+		si.is[len(indexstack)] = j
 
 		if omitEmpty {
 			si.omitEmpty = true
@@ -1068,16 +1258,16 @@ LOOP:
 
 // resolves the struct field info got from a call to rget.
 // Returns a trimmed, unsorted and sorted []*structFieldInfo.
-func rgetResolveSFI(x []*structFieldInfo, pv []sfiIdx) (y, z []*structFieldInfo) {
+func rgetResolveSFI(x []*structFieldInfo, pv []sfiIdx) (y, z []*structFieldInfo, anyOmitEmpty bool) {
 	var n int
 	for i, v := range x {
-		xn := v.encName //TODO: fieldName or encName? use encName for now.
+		xn := v.encName // TODO: fieldName or encName? use encName for now.
 		var found bool
 		for j, k := range pv {
 			if k.name == xn {
 				// one of them must be reset to nil, and the index updated appropriately to the other one
-				if len(v.is) == len(x[k.index].is) {
-				} else if len(v.is) < len(x[k.index].is) {
+				if v.nis == x[k.index].nis {
+				} else if v.nis < x[k.index].nis {
 					pv[j].index = i
 					if x[k.index] != nil {
 						x[k.index] = nil
@@ -1105,6 +1295,9 @@ func rgetResolveSFI(x []*structFieldInfo, pv []sfiIdx) (y, z []*structFieldInfo)
 		if v == nil {
 			continue
 		}
+		if !anyOmitEmpty && v.omitEmpty {
+			anyOmitEmpty = true
+		}
 		y[n] = v
 		n++
 	}
@@ -1115,15 +1308,65 @@ func rgetResolveSFI(x []*structFieldInfo, pv []sfiIdx) (y, z []*structFieldInfo)
 	return
 }
 
-func panicToErr(err *error) {
+func implIntf(rt, iTyp reflect.Type) (base bool, indir bool) {
+	return rt.Implements(iTyp), reflect.PtrTo(rt).Implements(iTyp)
+}
+
+// func round(x float64) float64 {
+// 	t := math.Trunc(x)
+// 	if math.Abs(x-t) >= 0.5 {
+// 		return t + math.Copysign(1, x)
+// 	}
+// 	return t
+// }
+
+func xprintf(format string, a ...interface{}) {
+	if xDebug {
+		fmt.Fprintf(os.Stderr, format, a...)
+	}
+}
+
+func panicToErr(h errstrDecorator, err *error) {
 	if recoverPanicToErr {
 		if x := recover(); x != nil {
-			//debug.PrintStack()
-			panicValToErr(x, err)
+			// if false && xDebug {
+			// 	fmt.Printf("panic'ing with: %v\n", x)
+			// 	debug.PrintStack()
+			// }
+			panicValToErr(h, x, err)
 		}
 	}
 }
 
+func panicToErrs2(h errstrDecorator, err1, err2 *error) {
+	if recoverPanicToErr {
+		if x := recover(); x != nil {
+			panicValToErr(h, x, err1)
+			panicValToErr(h, x, err2)
+		}
+	}
+}
+
+func panicValToErr(h errstrDecorator, v interface{}, err *error) {
+	switch xerr := v.(type) {
+	case nil:
+	case error:
+		switch xerr {
+		case nil:
+		case io.EOF, io.ErrUnexpectedEOF, errEncoderNotInitialized: // treat as special (bubble up)
+			*err = xerr
+		default:
+			h.wrapErrstr(xerr.Error(), err)
+		}
+	case string:
+		if xerr != "" {
+			h.wrapErrstr(xerr, err)
+		}
+	default:
+		h.wrapErrstr(v, err)
+	}
+}
+
 // func doPanic(tag string, format string, params ...interface{}) {
 // 	params2 := make([]interface{}, len(params)+1)
 // 	params2[0] = tag
@@ -1151,17 +1394,316 @@ func isImmutableKind(k reflect.Kind) (v bool) {
 	// 	k == reflect.String
 }
 
-// these functions must be inlinable, and not call anybody
+// ----
+
+// type codecFnInfoAddrKind uint8
+// const (
+// 	codecFnInfoAddrAddr codecFnInfoAddrKind = iota // default
+// 	codecFnInfoAddrBase
+// 	codecFnInfoAddrAddrElseBase
+// )
+
+type codecFnInfo struct {
+	ti    *typeInfo
+	xfFn  Ext
+	xfTag uint64
+	seq   seqType
+	addrD bool
+	addrF bool // if addrD, this says whether decode function can take a value or a ptr
+	addrE bool
+}
+
+// codecFn encapsulates the captured variables and the encode function.
+// This way, we only do some calculations one times, and pass to the
+// code block that should be called (encapsulated in a function)
+// instead of executing the checks every time.
+type codecFn struct {
+	i  codecFnInfo
+	fe func(*Encoder, *codecFnInfo, reflect.Value)
+	fd func(*Decoder, *codecFnInfo, reflect.Value)
+}
+
+type codecRtidFn struct {
+	rtid uintptr
+	fn   codecFn
+}
+
+type codecFner struct {
+	hh Handle
+	h  *BasicHandle
+	cs [arrayCacheLen]*[arrayCacheLen]codecRtidFn
+	s  []*[arrayCacheLen]codecRtidFn
+	sn uint32
+	be bool
+	js bool
+	cf [arrayCacheLen]codecRtidFn
+}
+
+func (c *codecFner) reset(hh Handle) {
+	c.hh = hh
+	c.h = hh.getBasicHandle()
+	_, c.js = hh.(*JsonHandle)
+	c.be = hh.isBinary()
+}
+
+func (c *codecFner) get(rt reflect.Type, checkFastpath, checkCodecSelfer bool) (fn *codecFn) {
+	rtid := rt2id(rt)
+	var j uint32
+	var sn uint32 = c.sn
+	if sn == 0 {
+		c.s = c.cs[:1]
+		c.s[0] = &c.cf
+		c.cf[0].rtid = rtid
+		fn = &(c.cf[0].fn)
+		c.sn = 1
+	} else {
+	LOOP1:
+		for _, x := range c.s {
+			for i := range x {
+				if j == sn {
+					break LOOP1
+				}
+				if x[i].rtid == rtid {
+					fn = &(x[i].fn)
+					return
+				}
+				j++
+			}
+		}
+		sx, sy := sn/arrayCacheLen, sn%arrayCacheLen
+		if sy == 0 {
+			c.s = append(c.s, &[arrayCacheLen]codecRtidFn{})
+		}
+		c.s[sx][sy].rtid = rtid
+		fn = &(c.s[sx][sy].fn)
+		c.sn++
+	}
+
+	ti := c.h.getTypeInfo(rtid, rt)
+	fi := &(fn.i)
+	fi.ti = ti
+
+	rk := rt.Kind()
+
+	if checkCodecSelfer && (ti.cs || ti.csp) {
+		fn.fe = (*Encoder).selferMarshal
+		fn.fd = (*Decoder).selferUnmarshal
+		fi.addrF = true
+		fi.addrD = ti.csp
+		fi.addrE = ti.csp
+	} else if rtid == timeTypId {
+		fn.fe = (*Encoder).kTime
+		fn.fd = (*Decoder).kTime
+	} else if rtid == rawTypId {
+		fn.fe = (*Encoder).raw
+		fn.fd = (*Decoder).raw
+	} else if rtid == rawExtTypId {
+		fn.fe = (*Encoder).rawExt
+		fn.fd = (*Decoder).rawExt
+		fi.addrF = true
+		fi.addrD = true
+		fi.addrE = true
+	} else if false && c.hh.IsBuiltinType(rtid) {
+		// TODO: remove this whole block. currently turned off with the "false &&"
+		// fn.fe = (*Encoder).builtin
+		// fn.fd = (*Decoder).builtin
+		// fi.addrF = true
+		// fi.addrD = true
+	} else if xfFn := c.h.getExt(rtid); xfFn != nil {
+		fi.xfTag, fi.xfFn = xfFn.tag, xfFn.ext
+		fn.fe = (*Encoder).ext
+		fn.fd = (*Decoder).ext
+		fi.addrF = true
+		fi.addrD = true
+		if rk == reflect.Struct || rk == reflect.Array {
+			fi.addrE = true
+		}
+	} else if supportMarshalInterfaces && c.be && (ti.bm || ti.bmp) && (ti.bu || ti.bup) {
+		fn.fe = (*Encoder).binaryMarshal
+		fn.fd = (*Decoder).binaryUnmarshal
+		fi.addrF = true
+		fi.addrD = ti.bup
+		fi.addrE = ti.bmp
+	} else if supportMarshalInterfaces && !c.be && c.js && (ti.jm || ti.jmp) && (ti.ju || ti.jup) {
+		//If JSON, we should check JSONMarshal before textMarshal
+		fn.fe = (*Encoder).jsonMarshal
+		fn.fd = (*Decoder).jsonUnmarshal
+		fi.addrF = true
+		fi.addrD = ti.jup
+		fi.addrE = ti.jmp
+	} else if supportMarshalInterfaces && !c.be && (ti.tm || ti.tmp) && (ti.tu || ti.tup) {
+		fn.fe = (*Encoder).textMarshal
+		fn.fd = (*Decoder).textUnmarshal
+		fi.addrF = true
+		fi.addrD = ti.tup
+		fi.addrE = ti.tmp
+	} else {
+		if fastpathEnabled && checkFastpath && (rk == reflect.Map || rk == reflect.Slice) {
+			if rt.PkgPath() == "" { // un-named slice or map
+				if idx := fastpathAV.index(rtid); idx != -1 {
+					fn.fe = fastpathAV[idx].encfn
+					fn.fd = fastpathAV[idx].decfn
+					fi.addrD = true
+					fi.addrF = false
+				}
+			} else {
+				// use mapping for underlying type if there
+				var rtu reflect.Type
+				if rk == reflect.Map {
+					rtu = reflect.MapOf(rt.Key(), rt.Elem())
+				} else {
+					rtu = reflect.SliceOf(rt.Elem())
+				}
+				rtuid := rt2id(rtu)
+				if idx := fastpathAV.index(rtuid); idx != -1 {
+					xfnf := fastpathAV[idx].encfn
+					xrt := fastpathAV[idx].rt
+					fn.fe = func(e *Encoder, xf *codecFnInfo, xrv reflect.Value) {
+						xfnf(e, xf, xrv.Convert(xrt))
+					}
+					fi.addrD = true
+					fi.addrF = false
+					xfnf2 := fastpathAV[idx].decfn
+					fn.fd = func(d *Decoder, xf *codecFnInfo, xrv reflect.Value) {
+						xfnf2(d, xf, xrv.Convert(reflect.PtrTo(xrt)))
+					}
+				}
+			}
+		}
+		if fn.fe == nil && fn.fd == nil {
+			switch rk {
+			case reflect.Bool:
+				fn.fe = (*Encoder).kBool
+				fn.fd = (*Decoder).kBool
+			case reflect.String:
+				fn.fe = (*Encoder).kString
+				fn.fd = (*Decoder).kString
+			case reflect.Int:
+				fn.fd = (*Decoder).kInt
+				fn.fe = (*Encoder).kInt
+			case reflect.Int8:
+				fn.fe = (*Encoder).kInt8
+				fn.fd = (*Decoder).kInt8
+			case reflect.Int16:
+				fn.fe = (*Encoder).kInt16
+				fn.fd = (*Decoder).kInt16
+			case reflect.Int32:
+				fn.fe = (*Encoder).kInt32
+				fn.fd = (*Decoder).kInt32
+			case reflect.Int64:
+				fn.fe = (*Encoder).kInt64
+				fn.fd = (*Decoder).kInt64
+			case reflect.Uint:
+				fn.fd = (*Decoder).kUint
+				fn.fe = (*Encoder).kUint
+			case reflect.Uint8:
+				fn.fe = (*Encoder).kUint8
+				fn.fd = (*Decoder).kUint8
+			case reflect.Uint16:
+				fn.fe = (*Encoder).kUint16
+				fn.fd = (*Decoder).kUint16
+			case reflect.Uint32:
+				fn.fe = (*Encoder).kUint32
+				fn.fd = (*Decoder).kUint32
+			case reflect.Uint64:
+				fn.fe = (*Encoder).kUint64
+				fn.fd = (*Decoder).kUint64
+				// case reflect.Ptr:
+				// 	fn.fd = (*Decoder).kPtr
+			case reflect.Uintptr:
+				fn.fe = (*Encoder).kUintptr
+				fn.fd = (*Decoder).kUintptr
+			case reflect.Float32:
+				fn.fe = (*Encoder).kFloat32
+				fn.fd = (*Decoder).kFloat32
+			case reflect.Float64:
+				fn.fe = (*Encoder).kFloat64
+				fn.fd = (*Decoder).kFloat64
+			case reflect.Invalid:
+				fn.fe = (*Encoder).kInvalid
+				fn.fd = (*Decoder).kErr
+			case reflect.Chan:
+				fi.seq = seqTypeChan
+				fn.fe = (*Encoder).kSlice
+				fn.fd = (*Decoder).kSlice
+			case reflect.Slice:
+				fi.seq = seqTypeSlice
+				fn.fe = (*Encoder).kSlice
+				fn.fd = (*Decoder).kSlice
+			case reflect.Array:
+				fi.seq = seqTypeArray
+				fn.fe = (*Encoder).kSlice
+				fi.addrF = false
+				fi.addrD = false
+				rt2 := reflect.SliceOf(rt.Elem())
+				fn.fd = func(d *Decoder, xf *codecFnInfo, xrv reflect.Value) {
+					// println(">>>>>> decoding an array ... ")
+					d.cf.get(rt2, true, false).fd(d, xf, xrv.Slice(0, xrv.Len()))
+					// println(">>>>>> decoding an array ... DONE")
+				}
+				// fn.fd = (*Decoder).kArray
+			case reflect.Struct:
+				if ti.anyOmitEmpty {
+					fn.fe = (*Encoder).kStruct
+				} else {
+					fn.fe = (*Encoder).kStructNoOmitempty
+				}
+				fn.fd = (*Decoder).kStruct
+				// reflect.Ptr and reflect.Interface are handled already by preEncodeValue
+				// case reflect.Ptr:
+				// 	fn.fe = (*Encoder).kPtr
+				// case reflect.Interface:
+				// 	fn.fe = (*Encoder).kInterface
+			case reflect.Map:
+				fn.fe = (*Encoder).kMap
+				fn.fd = (*Decoder).kMap
+			case reflect.Interface:
+				// encode: reflect.Interface are handled already by preEncodeValue
+				fn.fd = (*Decoder).kInterface
+				fn.fe = (*Encoder).kErr
+			default:
+				fn.fe = (*Encoder).kErr
+				fn.fd = (*Decoder).kErr
+			}
+		}
+	}
+
+	return
+}
+
+// ----
+
+func chkFloat32(f float64) (f32 float32) {
+	// f32 = float32(f)
+	if chkOvf.Float32(f) {
+		panicv.errorf("float32 overflow: %v", f)
+	}
+	return float32(f)
+}
+
+// these "checkOverflow" functions must be inlinable, and not call anybody.
+// Overflow means that the value cannot be represented without wrapping/overflow.
+// Overflow=false does not mean that the value can be represented without losing precision
+// (especially for floating point).
+
 type checkOverflow struct{}
 
-func (_ checkOverflow) Float32(f float64) (overflow bool) {
+// func (checkOverflow) Float16(f float64) (overflow bool) {
+// 	panicv.errorf("unimplemented")
+// 	if f < 0 {
+// 		f = -f
+// 	}
+// 	return math.MaxFloat32 < f && f <= math.MaxFloat64
+// }
+
+func (checkOverflow) Float32(f float64) (overflow bool) {
 	if f < 0 {
 		f = -f
 	}
 	return math.MaxFloat32 < f && f <= math.MaxFloat64
 }
 
-func (_ checkOverflow) Uint(v uint64, bitsize uint8) (overflow bool) {
+func (checkOverflow) Uint(v uint64, bitsize uint8) (overflow bool) {
 	if bitsize == 0 || bitsize >= 64 || v == 0 {
 		return
 	}
@@ -1171,7 +1713,7 @@ func (_ checkOverflow) Uint(v uint64, bitsize uint8) (overflow bool) {
 	return
 }
 
-func (_ checkOverflow) Int(v int64, bitsize uint8) (overflow bool) {
+func (checkOverflow) Int(v int64, bitsize uint8) (overflow bool) {
 	if bitsize == 0 || bitsize >= 64 || v == 0 {
 		return
 	}
@@ -1181,22 +1723,23 @@ func (_ checkOverflow) Int(v int64, bitsize uint8) (overflow bool) {
 	return
 }
 
-func (_ checkOverflow) SignedInt(v uint64) (i int64, overflow bool) {
+func (checkOverflow) SignedInt(v uint64) (i int64, overflow bool) {
 	//e.g. -127 to 128 for int8
 	pos := (v >> 63) == 0
 	ui2 := v & 0x7fffffffffffffff
 	if pos {
 		if ui2 > math.MaxInt64 {
 			overflow = true
-			return
+		} else {
+			i = int64(v)
 		}
 	} else {
 		if ui2 > math.MaxInt64-1 {
 			overflow = true
-			return
+		} else {
+			i = int64(v)
 		}
 	}
-	i = int64(v)
 	return
 }
 
@@ -1206,8 +1749,23 @@ func isNaN(f float64) bool { return f != f }
 
 // -----------------------
 
+type ioFlusher interface {
+	Flush() error
+}
+
+type ioPeeker interface {
+	Peek(int) ([]byte, error)
+}
+
+type ioBuffered interface {
+	Buffered() int
+}
+
+// -----------------------
+
 type intSlice []int64
 type uintSlice []uint64
+type uintptrSlice []uintptr
 type floatSlice []float64
 type boolSlice []bool
 type stringSlice []string
@@ -1221,6 +1779,10 @@ func (p uintSlice) Len() int           { return len(p) }
 func (p uintSlice) Less(i, j int) bool { return p[i] < p[j] }
 func (p uintSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
 
+func (p uintptrSlice) Len() int           { return len(p) }
+func (p uintptrSlice) Less(i, j int) bool { return p[i] < p[j] }
+func (p uintptrSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+
 func (p floatSlice) Len() int { return len(p) }
 func (p floatSlice) Less(i, j int) bool {
 	return p[i] < p[j] || isNaN(p[i]) && !isNaN(p[j])
@@ -1271,6 +1833,11 @@ type bytesRv struct {
 	r reflect.Value
 }
 type bytesRvSlice []bytesRv
+type timeRv struct {
+	v time.Time
+	r reflect.Value
+}
+type timeRvSlice []timeRv
 
 func (p intRvSlice) Len() int           { return len(p) }
 func (p intRvSlice) Less(i, j int) bool { return p[i].v < p[j].v }
@@ -1298,6 +1865,10 @@ func (p boolRvSlice) Len() int           { return len(p) }
 func (p boolRvSlice) Less(i, j int) bool { return !p[i].v && p[j].v }
 func (p boolRvSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
 
+func (p timeRvSlice) Len() int           { return len(p) }
+func (p timeRvSlice) Less(i, j int) bool { return p[i].v.Before(p[j].v) }
+func (p timeRvSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+
 // -----------------
 
 type bytesI struct {
@@ -1317,7 +1888,6 @@ type set []uintptr
 
 func (s *set) add(v uintptr) (exists bool) {
 	// e.ci is always nil, or len >= 1
-	// defer func() { fmt.Printf("$$$$$$$$$$$ cirRef Add: %v, exists: %v\n", v, exists) }()
 	x := *s
 	if x == nil {
 		x = make([]uintptr, 1, 8)
@@ -1358,7 +1928,6 @@ func (s *set) add(v uintptr) (exists bool) {
 }
 
 func (s *set) remove(v uintptr) (exists bool) {
-	// defer func() { fmt.Printf("$$$$$$$$$$$ cirRef Rm: %v, exists: %v\n", v, exists) }()
 	x := *s
 	if len(x) == 0 {
 		return
@@ -1380,3 +1949,151 @@ func (s *set) remove(v uintptr) (exists bool) {
 	}
 	return
 }
+
+// ------
+
+// bitset types are better than [256]bool, because they permit the whole
+// bitset array being on a single cache line and use less memory.
+
+// given x > 0 and n > 0 and x is exactly 2^n, then pos/x === pos>>n AND pos%x === pos&(x-1).
+// consequently, pos/32 === pos>>5, pos/16 === pos>>4, pos/8 === pos>>3, pos%8 == pos&7
+
+type bitset256 [32]byte
+
+func (x *bitset256) isset(pos byte) bool {
+	return x[pos>>3]&(1<<(pos&7)) != 0
+}
+func (x *bitset256) set(pos byte) {
+	x[pos>>3] |= (1 << (pos & 7))
+}
+
+// func (x *bitset256) unset(pos byte) {
+// 	x[pos>>3] &^= (1 << (pos & 7))
+// }
+
+type bitset128 [16]byte
+
+func (x *bitset128) isset(pos byte) bool {
+	return x[pos>>3]&(1<<(pos&7)) != 0
+}
+func (x *bitset128) set(pos byte) {
+	x[pos>>3] |= (1 << (pos & 7))
+}
+
+// func (x *bitset128) unset(pos byte) {
+// 	x[pos>>3] &^= (1 << (pos & 7))
+// }
+
+type bitset32 [4]byte
+
+func (x *bitset32) isset(pos byte) bool {
+	return x[pos>>3]&(1<<(pos&7)) != 0
+}
+func (x *bitset32) set(pos byte) {
+	x[pos>>3] |= (1 << (pos & 7))
+}
+
+// func (x *bitset32) unset(pos byte) {
+// 	x[pos>>3] &^= (1 << (pos & 7))
+// }
+
+// ------------
+
+type pooler struct {
+	// for stringRV
+	strRv8, strRv16, strRv32, strRv64, strRv128 sync.Pool
+	// for the decNaked
+	dn     sync.Pool
+	tiload sync.Pool
+}
+
+func (p *pooler) init() {
+	p.strRv8.New = func() interface{} { return new([8]stringRv) }
+	p.strRv16.New = func() interface{} { return new([16]stringRv) }
+	p.strRv32.New = func() interface{} { return new([32]stringRv) }
+	p.strRv64.New = func() interface{} { return new([64]stringRv) }
+	p.strRv128.New = func() interface{} { return new([128]stringRv) }
+	p.dn.New = func() interface{} { x := new(decNaked); x.init(); return x }
+	p.tiload.New = func() interface{} { return new(typeInfoLoadArray) }
+}
+
+func (p *pooler) stringRv8() (sp *sync.Pool, v interface{}) {
+	return &p.strRv8, p.strRv8.Get()
+}
+func (p *pooler) stringRv16() (sp *sync.Pool, v interface{}) {
+	return &p.strRv16, p.strRv16.Get()
+}
+func (p *pooler) stringRv32() (sp *sync.Pool, v interface{}) {
+	return &p.strRv32, p.strRv32.Get()
+}
+func (p *pooler) stringRv64() (sp *sync.Pool, v interface{}) {
+	return &p.strRv64, p.strRv64.Get()
+}
+func (p *pooler) stringRv128() (sp *sync.Pool, v interface{}) {
+	return &p.strRv128, p.strRv128.Get()
+}
+func (p *pooler) decNaked() (sp *sync.Pool, v interface{}) {
+	return &p.dn, p.dn.Get()
+}
+func (p *pooler) tiLoad() (sp *sync.Pool, v interface{}) {
+	return &p.tiload, p.tiload.Get()
+}
+
+type panicHdl struct{}
+
+func (panicHdl) errorv(err error) {
+	if err != nil {
+		panic(err)
+	}
+}
+
+func (panicHdl) errorstr(message string) {
+	if message != "" {
+		panic(message)
+	}
+}
+
+func (panicHdl) errorf(format string, params ...interface{}) {
+	if format != "" {
+		if len(params) == 0 {
+			panic(format)
+		} else {
+			panic(fmt.Sprintf(format, params...))
+		}
+	}
+}
+
+type errstrDecorator interface {
+	wrapErrstr(interface{}, *error)
+}
+
+type errstrDecoratorDef struct{}
+
+func (errstrDecoratorDef) wrapErrstr(v interface{}, e *error) { *e = fmt.Errorf("%v", v) }
+
+type must struct{}
+
+func (must) String(s string, err error) string {
+	if err != nil {
+		panicv.errorv(err)
+	}
+	return s
+}
+func (must) Int(s int64, err error) int64 {
+	if err != nil {
+		panicv.errorv(err)
+	}
+	return s
+}
+func (must) Uint(s uint64, err error) uint64 {
+	if err != nil {
+		panicv.errorv(err)
+	}
+	return s
+}
+func (must) Float(s float64, err error) float64 {
+	if err != nil {
+		panicv.errorv(err)
+	}
+	return s
+}
diff --git a/vendor/github.com/ugorji/go/codec/helper_internal.go b/vendor/github.com/ugorji/go/codec/helper_internal.go
index eb18e2cca..c5da51450 100644
--- a/vendor/github.com/ugorji/go/codec/helper_internal.go
+++ b/vendor/github.com/ugorji/go/codec/helper_internal.go
@@ -7,28 +7,10 @@ package codec
 // so porting to different environment is easy (just update functions).
 
 import (
-	"errors"
-	"fmt"
-	"math"
 	"reflect"
+	"time"
 )
 
-func panicValToErr(panicVal interface{}, err *error) {
-	if panicVal == nil {
-		return
-	}
-	// case nil
-	switch xerr := panicVal.(type) {
-	case error:
-		*err = xerr
-	case string:
-		*err = errors.New(xerr)
-	default:
-		*err = fmt.Errorf("%v", panicVal)
-	}
-	return
-}
-
 func hIsEmptyValue(v reflect.Value, deref, checkStruct bool) bool {
 	switch v.Kind() {
 	case reflect.Invalid:
@@ -49,10 +31,13 @@ func hIsEmptyValue(v reflect.Value, deref, checkStruct bool) bool {
 				return true
 			}
 			return hIsEmptyValue(v.Elem(), deref, checkStruct)
-		} else {
-			return v.IsNil()
 		}
+		return v.IsNil()
 	case reflect.Struct:
+		// check for time.Time, and return true if IsZero
+		if rv2rtid(v) == timeTypId {
+			return rv2i(v).(time.Time).IsZero()
+		}
 		if !checkStruct {
 			return false
 		}
@@ -86,37 +71,6 @@ func pruneSignExt(v []byte, pos bool) (n int) {
 	return
 }
 
-func implementsIntf(typ, iTyp reflect.Type) (success bool, indir int8) {
-	if typ == nil {
-		return
-	}
-	rt := typ
-	// The type might be a pointer and we need to keep
-	// dereferencing to the base type until we find an implementation.
-	for {
-		if rt.Implements(iTyp) {
-			return true, indir
-		}
-		if p := rt; p.Kind() == reflect.Ptr {
-			indir++
-			if indir >= math.MaxInt8 { // insane number of indirections
-				return false, 0
-			}
-			rt = p.Elem()
-			continue
-		}
-		break
-	}
-	// No luck yet, but if this is a base type (non-pointer), the pointer might satisfy.
-	if typ.Kind() != reflect.Ptr {
-		// Not a pointer, but does the pointer work?
-		if reflect.PtrTo(typ).Implements(iTyp) {
-			return true, -1
-		}
-	}
-	return false, 0
-}
-
 // validate that this function is correct ...
 // culled from OGRE (Object-Oriented Graphics Rendering Engine)
 // function: halfToFloatI (http://stderr.org/doc/ogre-doc/api/OgreBitwise_8h-source.html)
@@ -129,21 +83,20 @@ func halfFloatToFloatBits(yy uint16) (d uint32) {
 	if e == 0 {
 		if m == 0 { // plu or minus 0
 			return s << 31
-		} else { // Denormalized number -- renormalize it
-			for (m & 0x00000400) == 0 {
-				m <<= 1
-				e -= 1
-			}
-			e += 1
-			const zz uint32 = 0x0400
-			m &= ^zz
 		}
+		// Denormalized number -- renormalize it
+		for (m & 0x00000400) == 0 {
+			m <<= 1
+			e -= 1
+		}
+		e += 1
+		const zz uint32 = 0x0400
+		m &= ^zz
 	} else if e == 31 {
 		if m == 0 { // Inf
 			return (s << 31) | 0x7f800000
-		} else { // NaN
-			return (s << 31) | 0x7f800000 | (m << 13)
 		}
+		return (s << 31) | 0x7f800000 | (m << 13) // NaN
 	}
 	e = e + (127 - 15)
 	m = m << 13
diff --git a/vendor/github.com/ugorji/go/codec/helper_not_unsafe.go b/vendor/github.com/ugorji/go/codec/helper_not_unsafe.go
index d80e18f60..3d5f3db8f 100644
--- a/vendor/github.com/ugorji/go/codec/helper_not_unsafe.go
+++ b/vendor/github.com/ugorji/go/codec/helper_not_unsafe.go
@@ -8,8 +8,11 @@ package codec
 import (
 	"reflect"
 	"sync/atomic"
+	"time"
 )
 
+const safeMode = true
+
 // stringView returns a view of the []byte as a string.
 // In unsafe mode, it doesn't incur allocation and copying caused by conversion.
 // In regular safe mode, it is an allocation and copy.
@@ -30,6 +33,21 @@ func bytesView(v string) []byte {
 	return []byte(v)
 }
 
+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() {
+	// case reflect.Invalid:
+	// 	return true
+	// case reflect.Ptr, reflect.Interface, reflect.Chan, reflect.Slice, reflect.Map, reflect.Func:
+	// 	return rv.IsNil()
+	// default:
+	// 	return false
+	// }
+}
+
 // // keepAlive4BytesView maintains a reference to the input parameter for bytesView.
 // //
 // // Usage: call this at point where done with the bytes view.
@@ -48,14 +66,22 @@ func rt2id(rt reflect.Type) uintptr {
 	return reflect.ValueOf(rt).Pointer()
 }
 
-// --------------------------
-type ptrToRvMap struct{}
-
-func (_ *ptrToRvMap) init() {}
-func (_ *ptrToRvMap) get(i interface{}) reflect.Value {
-	return reflect.ValueOf(i).Elem()
+func rv2rtid(rv reflect.Value) uintptr {
+	return reflect.ValueOf(rv.Type()).Pointer()
 }
 
+func i2rtid(i interface{}) uintptr {
+	return reflect.ValueOf(reflect.TypeOf(i)).Pointer()
+}
+
+// --------------------------
+// type ptrToRvMap struct{}
+
+// func (*ptrToRvMap) init() {}
+// func (*ptrToRvMap) get(i interface{}) reflect.Value {
+// 	return reflect.ValueOf(i).Elem()
+// }
+
 // --------------------------
 type atomicTypeInfoSlice struct {
 	v atomic.Value
@@ -74,70 +100,140 @@ func (x *atomicTypeInfoSlice) store(p *[]rtid2ti) {
 }
 
 // --------------------------
-func (f *decFnInfo) raw(rv reflect.Value) {
-	rv.SetBytes(f.d.raw())
+func (d *Decoder) raw(f *codecFnInfo, rv reflect.Value) {
+	rv.SetBytes(d.rawBytes())
 }
 
-func (f *decFnInfo) kString(rv reflect.Value) {
-	rv.SetString(f.d.d.DecodeString())
+func (d *Decoder) kString(f *codecFnInfo, rv reflect.Value) {
+	rv.SetString(d.d.DecodeString())
 }
 
-func (f *decFnInfo) kBool(rv reflect.Value) {
-	rv.SetBool(f.d.d.DecodeBool())
+func (d *Decoder) kBool(f *codecFnInfo, rv reflect.Value) {
+	rv.SetBool(d.d.DecodeBool())
 }
 
-func (f *decFnInfo) kFloat32(rv reflect.Value) {
-	rv.SetFloat(f.d.d.DecodeFloat(true))
+func (d *Decoder) kTime(f *codecFnInfo, rv reflect.Value) {
+	rv.Set(reflect.ValueOf(d.d.DecodeTime()))
 }
 
-func (f *decFnInfo) kFloat64(rv reflect.Value) {
-	rv.SetFloat(f.d.d.DecodeFloat(false))
+func (d *Decoder) kFloat32(f *codecFnInfo, rv reflect.Value) {
+	fv := d.d.DecodeFloat64()
+	if chkOvf.Float32(fv) {
+		d.errorf("float32 overflow: %v", fv)
+	}
+	rv.SetFloat(fv)
 }
 
-func (f *decFnInfo) kInt(rv reflect.Value) {
-	rv.SetInt(f.d.d.DecodeInt(intBitsize))
+func (d *Decoder) kFloat64(f *codecFnInfo, rv reflect.Value) {
+	rv.SetFloat(d.d.DecodeFloat64())
 }
 
-func (f *decFnInfo) kInt8(rv reflect.Value) {
-	rv.SetInt(f.d.d.DecodeInt(8))
+func (d *Decoder) kInt(f *codecFnInfo, rv reflect.Value) {
+	rv.SetInt(d.d.DecodeInt(intBitsize))
 }
 
-func (f *decFnInfo) kInt16(rv reflect.Value) {
-	rv.SetInt(f.d.d.DecodeInt(16))
+func (d *Decoder) kInt8(f *codecFnInfo, rv reflect.Value) {
+	rv.SetInt(d.d.DecodeInt(8))
 }
 
-func (f *decFnInfo) kInt32(rv reflect.Value) {
-	rv.SetInt(f.d.d.DecodeInt(32))
+func (d *Decoder) kInt16(f *codecFnInfo, rv reflect.Value) {
+	rv.SetInt(d.d.DecodeInt(16))
 }
 
-func (f *decFnInfo) kInt64(rv reflect.Value) {
-	rv.SetInt(f.d.d.DecodeInt(64))
+func (d *Decoder) kInt32(f *codecFnInfo, rv reflect.Value) {
+	rv.SetInt(d.d.DecodeInt(32))
 }
 
-func (f *decFnInfo) kUint(rv reflect.Value) {
-	rv.SetUint(f.d.d.DecodeUint(uintBitsize))
+func (d *Decoder) kInt64(f *codecFnInfo, rv reflect.Value) {
+	rv.SetInt(d.d.DecodeInt(64))
 }
 
-func (f *decFnInfo) kUintptr(rv reflect.Value) {
-	rv.SetUint(f.d.d.DecodeUint(uintBitsize))
+func (d *Decoder) kUint(f *codecFnInfo, rv reflect.Value) {
+	rv.SetUint(d.d.DecodeUint(uintBitsize))
 }
 
-func (f *decFnInfo) kUint8(rv reflect.Value) {
-	rv.SetUint(f.d.d.DecodeUint(8))
+func (d *Decoder) kUintptr(f *codecFnInfo, rv reflect.Value) {
+	rv.SetUint(d.d.DecodeUint(uintBitsize))
 }
 
-func (f *decFnInfo) kUint16(rv reflect.Value) {
-	rv.SetUint(f.d.d.DecodeUint(16))
+func (d *Decoder) kUint8(f *codecFnInfo, rv reflect.Value) {
+	rv.SetUint(d.d.DecodeUint(8))
 }
 
-func (f *decFnInfo) kUint32(rv reflect.Value) {
-	rv.SetUint(f.d.d.DecodeUint(32))
+func (d *Decoder) kUint16(f *codecFnInfo, rv reflect.Value) {
+	rv.SetUint(d.d.DecodeUint(16))
 }
 
-func (f *decFnInfo) kUint64(rv reflect.Value) {
-	rv.SetUint(f.d.d.DecodeUint(64))
+func (d *Decoder) kUint32(f *codecFnInfo, rv reflect.Value) {
+	rv.SetUint(d.d.DecodeUint(32))
 }
 
-// func i2rv(i interface{}) reflect.Value {
-// 	return reflect.ValueOf(i)
-// }
+func (d *Decoder) kUint64(f *codecFnInfo, rv reflect.Value) {
+	rv.SetUint(d.d.DecodeUint(64))
+}
+
+// ----------------
+
+func (e *Encoder) kBool(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeBool(rv.Bool())
+}
+
+func (e *Encoder) kTime(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeTime(rv2i(rv).(time.Time))
+}
+
+func (e *Encoder) kString(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeString(cUTF8, rv.String())
+}
+
+func (e *Encoder) kFloat64(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeFloat64(rv.Float())
+}
+
+func (e *Encoder) kFloat32(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeFloat32(float32(rv.Float()))
+}
+
+func (e *Encoder) kInt(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeInt(rv.Int())
+}
+
+func (e *Encoder) kInt8(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeInt(rv.Int())
+}
+
+func (e *Encoder) kInt16(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeInt(rv.Int())
+}
+
+func (e *Encoder) kInt32(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeInt(rv.Int())
+}
+
+func (e *Encoder) kInt64(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeInt(rv.Int())
+}
+
+func (e *Encoder) kUint(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeUint(rv.Uint())
+}
+
+func (e *Encoder) kUint8(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeUint(rv.Uint())
+}
+
+func (e *Encoder) kUint16(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeUint(rv.Uint())
+}
+
+func (e *Encoder) kUint32(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeUint(rv.Uint())
+}
+
+func (e *Encoder) kUint64(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeUint(rv.Uint())
+}
+
+func (e *Encoder) kUintptr(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeUint(rv.Uint())
+}
diff --git a/vendor/github.com/ugorji/go/codec/helper_test.go b/vendor/github.com/ugorji/go/codec/helper_test.go
index 611eac43d..a765fd4a4 100644
--- a/vendor/github.com/ugorji/go/codec/helper_test.go
+++ b/vendor/github.com/ugorji/go/codec/helper_test.go
@@ -8,41 +8,9 @@ package codec
 
 import (
 	"errors"
-	"fmt"
 	"reflect"
-	"testing"
 )
 
-// ----- functions below are used only by tests (not benchmarks)
-
-const (
-	testLogToT    = true
-	failNowOnFail = true
-)
-
-func checkErrT(t *testing.T, err error) {
-	if err != nil {
-		logT(t, err.Error())
-		failT(t)
-	}
-}
-
-func checkEqualT(t *testing.T, v1 interface{}, v2 interface{}, desc string) (err error) {
-	if err = deepEqual(v1, v2); err != nil {
-		logT(t, "Not Equal: %s: %v. v1: %v, v2: %v", desc, err, v1, v2)
-		failT(t)
-	}
-	return
-}
-
-func failT(t *testing.T) {
-	if failNowOnFail {
-		t.FailNow()
-	} else {
-		t.Fail()
-	}
-}
-
 // --- these functions are used by both benchmarks and tests
 
 func deepEqual(v1, v2 interface{}) (err error) {
@@ -52,21 +20,6 @@ func deepEqual(v1, v2 interface{}) (err error) {
 	return
 }
 
-func logT(x interface{}, format string, args ...interface{}) {
-	if t, ok := x.(*testing.T); ok && t != nil && testLogToT {
-		if testVerbose {
-			t.Logf(format, args...)
-		}
-	} else if b, ok := x.(*testing.B); ok && b != nil && testLogToT {
-		b.Logf(format, args...)
-	} else {
-		if len(format) == 0 || format[len(format)-1] != '\n' {
-			format = format + "\n"
-		}
-		fmt.Printf(format, args...)
-	}
-}
-
 func approxDataSize(rv reflect.Value) (sum int) {
 	switch rk := rv.Kind(); rk {
 	case reflect.Invalid:
diff --git a/vendor/github.com/ugorji/go/codec/helper_unsafe.go b/vendor/github.com/ugorji/go/codec/helper_unsafe.go
index d23e6e461..e43ab7258 100644
--- a/vendor/github.com/ugorji/go/codec/helper_unsafe.go
+++ b/vendor/github.com/ugorji/go/codec/helper_unsafe.go
@@ -10,6 +10,7 @@ package codec
 import (
 	"reflect"
 	"sync/atomic"
+	"time"
 	"unsafe"
 )
 
@@ -18,6 +19,9 @@ import (
 
 // var zeroRTv [4]uintptr
 
+const safeMode = false
+const unsafeFlagIndir = 1 << 7 // keep in sync with GO_ROOT/src/reflect/value.go
+
 type unsafeString struct {
 	Data uintptr
 	Len  int
@@ -60,6 +64,31 @@ func bytesView(v string) []byte {
 	return *(*[]byte)(unsafe.Pointer(&bx))
 }
 
+func definitelyNil(v interface{}) bool {
+	// 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.
+	//
+	// However, the following are cheap calls
+	// - TypeOf(interface): cheap 2-line call.
+	// - ValueOf(interface{}): expensive
+	// - type.Kind: cheap call through an interface
+	// - Value.Type(): cheap call
+	//                 except it's a method value (e.g. r.Read, which implies that it is a Func)
+
+	return ((*unsafeIntf)(unsafe.Pointer(&v))).word == nil
+
+	// var ui *unsafeIntf = (*unsafeIntf)(unsafe.Pointer(&v))
+	// if ui.word == nil {
+	// 	return true
+	// }
+	// var tk = reflect.TypeOf(v).Kind()
+	// return (tk == reflect.Interface || tk == reflect.Slice) && *(*unsafe.Pointer)(ui.word) == nil
+	// 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)
+}
+
 // func keepAlive4BytesView(v string) {
 // 	runtime.KeepAlive(v)
 // }
@@ -68,30 +97,38 @@ func bytesView(v string) []byte {
 // 	runtime.KeepAlive(v)
 // }
 
-const _unsafe_rv2i_is_safe = false
-
 // TODO: consider a more generally-known optimization for reflect.Value ==> Interface
 //
 // Currently, we use this fragile method that taps into implememtation details from
-// the source go stdlib reflect/value.go,
-// and trims the implementation.
+// the source go stdlib reflect/value.go, and trims the implementation.
 func rv2i(rv reflect.Value) interface{} {
-	if _unsafe_rv2i_is_safe {
-		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&(1<<7) != 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 {
 	return uintptr(((*unsafeIntf)(unsafe.Pointer(&rt))).word)
 }
 
+func rv2rtid(rv reflect.Value) uintptr {
+	return uintptr((*unsafeReflectValue)(unsafe.Pointer(&rv)).typ)
+}
+
+func i2rtid(i interface{}) uintptr {
+	return uintptr(((*unsafeIntf)(unsafe.Pointer(&i))).typ)
+}
+
 // func rv0t(rt reflect.Type) reflect.Value {
 // 	ut := (*unsafeIntf)(unsafe.Pointer(&rt))
 // 	// we need to determine whether ifaceIndir, and then whether to just pass 0 as the ptr
@@ -99,48 +136,6 @@ func rt2id(rt reflect.Type) uintptr {
 // 	return *(*reflect.Value)(unsafe.Pointer(&uv})
 // }
 
-type ptrToRVKV struct {
-	k uintptr
-	v reflect.Value
-}
-
-type ptrToRvMap struct {
-	// m map[uintptr]reflect.Value
-	a [4]ptrToRVKV
-	v []ptrToRVKV
-}
-
-func (p *ptrToRvMap) init() {
-	// fmt.Printf(">>>> new ptr to rv map\n")
-	// p.m = make(map[uintptr]reflect.Value, 32)
-	p.v = p.a[:0]
-}
-
-func (p *ptrToRvMap) get(intf interface{}) (rv reflect.Value) {
-	word := uintptr(((*unsafeIntf)(unsafe.Pointer(&intf))).word)
-	// binary search. adapted from sort/search.go.
-	h, i, j := 0, 0, len(p.v)
-	for i < j {
-		h = i + (j-i)/2
-		if p.v[h].k < word {
-			i = h + 1
-		} else {
-			j = h
-		}
-	}
-	if i < len(p.v) && p.v[i].k == word {
-		return p.v[i].v
-	}
-
-	// insert into position i
-	// fmt.Printf(">>>> resetting rv for word: %x, interface: %v\n", word, intf)
-	rv = reflect.ValueOf(intf).Elem()
-	p.v = append(p.v, ptrToRVKV{})
-	copy(p.v[i+1:len(p.v)], p.v[i:len(p.v)-1])
-	p.v[i].k, p.v[i].v = word, rv
-	return
-}
-
 // --------------------------
 type atomicTypeInfoSlice struct {
 	v unsafe.Pointer
@@ -155,95 +150,181 @@ func (x *atomicTypeInfoSlice) store(p *[]rtid2ti) {
 }
 
 // --------------------------
-func (f *decFnInfo) raw(rv reflect.Value) {
+func (d *Decoder) raw(f *codecFnInfo, rv reflect.Value) {
 	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
-	*(*[]byte)(urv.ptr) = f.d.raw()
+	// if urv.flag&unsafeFlagIndir != 0 {
+	// 	urv.ptr = *(*unsafe.Pointer)(urv.ptr)
+	// }
+	*(*[]byte)(urv.ptr) = d.rawBytes()
 }
 
-func (f *decFnInfo) kString(rv reflect.Value) {
+func (d *Decoder) kString(f *codecFnInfo, rv reflect.Value) {
 	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
-	*(*string)(urv.ptr) = f.d.d.DecodeString()
+	*(*string)(urv.ptr) = d.d.DecodeString()
 }
 
-func (f *decFnInfo) kBool(rv reflect.Value) {
+func (d *Decoder) kBool(f *codecFnInfo, rv reflect.Value) {
 	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
-	*(*bool)(urv.ptr) = f.d.d.DecodeBool()
+	*(*bool)(urv.ptr) = d.d.DecodeBool()
 }
 
-func (f *decFnInfo) kFloat32(rv reflect.Value) {
+func (d *Decoder) kTime(f *codecFnInfo, rv reflect.Value) {
 	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
-	*(*float32)(urv.ptr) = float32(f.d.d.DecodeFloat(true))
+	*(*time.Time)(urv.ptr) = d.d.DecodeTime()
 }
 
-func (f *decFnInfo) kFloat64(rv reflect.Value) {
+func (d *Decoder) kFloat32(f *codecFnInfo, rv reflect.Value) {
+	fv := d.d.DecodeFloat64()
+	if chkOvf.Float32(fv) {
+		d.errorf("float32 overflow: %v", fv)
+	}
 	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
-	*(*float64)(urv.ptr) = f.d.d.DecodeFloat(false)
+	*(*float32)(urv.ptr) = float32(fv)
 }
 
-func (f *decFnInfo) kInt(rv reflect.Value) {
+func (d *Decoder) kFloat64(f *codecFnInfo, rv reflect.Value) {
 	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
-	*(*int)(urv.ptr) = int(f.d.d.DecodeInt(intBitsize))
+	*(*float64)(urv.ptr) = d.d.DecodeFloat64()
 }
 
-func (f *decFnInfo) kInt8(rv reflect.Value) {
+func (d *Decoder) kInt(f *codecFnInfo, rv reflect.Value) {
 	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
-	*(*int8)(urv.ptr) = int8(f.d.d.DecodeInt(8))
+	*(*int)(urv.ptr) = int(d.d.DecodeInt(intBitsize))
 }
 
-func (f *decFnInfo) kInt16(rv reflect.Value) {
+func (d *Decoder) kInt8(f *codecFnInfo, rv reflect.Value) {
 	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
-	*(*int16)(urv.ptr) = int16(f.d.d.DecodeInt(16))
+	*(*int8)(urv.ptr) = int8(d.d.DecodeInt(8))
 }
 
-func (f *decFnInfo) kInt32(rv reflect.Value) {
+func (d *Decoder) kInt16(f *codecFnInfo, rv reflect.Value) {
 	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
-	*(*int32)(urv.ptr) = int32(f.d.d.DecodeInt(32))
+	*(*int16)(urv.ptr) = int16(d.d.DecodeInt(16))
 }
 
-func (f *decFnInfo) kInt64(rv reflect.Value) {
+func (d *Decoder) kInt32(f *codecFnInfo, rv reflect.Value) {
 	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
-	*(*int64)(urv.ptr) = f.d.d.DecodeInt(64)
+	*(*int32)(urv.ptr) = int32(d.d.DecodeInt(32))
 }
 
-func (f *decFnInfo) kUint(rv reflect.Value) {
+func (d *Decoder) kInt64(f *codecFnInfo, rv reflect.Value) {
 	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
-	*(*uint)(urv.ptr) = uint(f.d.d.DecodeUint(uintBitsize))
+	*(*int64)(urv.ptr) = d.d.DecodeInt(64)
 }
 
-func (f *decFnInfo) kUintptr(rv reflect.Value) {
+func (d *Decoder) kUint(f *codecFnInfo, rv reflect.Value) {
 	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
-	*(*uintptr)(urv.ptr) = uintptr(f.d.d.DecodeUint(uintBitsize))
+	*(*uint)(urv.ptr) = uint(d.d.DecodeUint(uintBitsize))
 }
 
-func (f *decFnInfo) kUint8(rv reflect.Value) {
+func (d *Decoder) kUintptr(f *codecFnInfo, rv reflect.Value) {
 	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
-	*(*uint8)(urv.ptr) = uint8(f.d.d.DecodeUint(8))
+	*(*uintptr)(urv.ptr) = uintptr(d.d.DecodeUint(uintBitsize))
 }
 
-func (f *decFnInfo) kUint16(rv reflect.Value) {
+func (d *Decoder) kUint8(f *codecFnInfo, rv reflect.Value) {
 	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
-	*(*uint16)(urv.ptr) = uint16(f.d.d.DecodeUint(16))
+	*(*uint8)(urv.ptr) = uint8(d.d.DecodeUint(8))
 }
 
-func (f *decFnInfo) kUint32(rv reflect.Value) {
+func (d *Decoder) kUint16(f *codecFnInfo, rv reflect.Value) {
 	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
-	*(*uint32)(urv.ptr) = uint32(f.d.d.DecodeUint(32))
-}
-func (f *decFnInfo) kUint64(rv reflect.Value) {
-	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
-	*(*uint64)(urv.ptr) = f.d.d.DecodeUint(64)
+	*(*uint16)(urv.ptr) = uint16(d.d.DecodeUint(16))
 }
 
-// func (p *ptrToRvMap) get(i interface{}) (rv reflect.Value) {
-// 	word := uintptr(((*unsafeIntf)(unsafe.Pointer(&i))).word)
-// 	rv, exists := p.m[word]
-// 	if !exists {
-// 		fmt.Printf(">>>> resetting rv for word: %x, interface: %v\n", word, i)
-// 		rv = reflect.ValueOf(i).Elem()
-// 		p.m[word] = rv
-// 	}
-// 	return
-// }
+func (d *Decoder) kUint32(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*uint32)(urv.ptr) = uint32(d.d.DecodeUint(32))
+}
+
+func (d *Decoder) kUint64(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*uint64)(urv.ptr) = d.d.DecodeUint(64)
+}
+
+// ------------
+
+func (e *Encoder) kBool(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeBool(*(*bool)(v.ptr))
+}
+
+func (e *Encoder) kTime(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeTime(*(*time.Time)(v.ptr))
+}
+
+func (e *Encoder) kString(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeString(cUTF8, *(*string)(v.ptr))
+}
+
+func (e *Encoder) kFloat64(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeFloat64(*(*float64)(v.ptr))
+}
+
+func (e *Encoder) kFloat32(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeFloat32(*(*float32)(v.ptr))
+}
+
+func (e *Encoder) kInt(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeInt(int64(*(*int)(v.ptr)))
+}
+
+func (e *Encoder) kInt8(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeInt(int64(*(*int8)(v.ptr)))
+}
+
+func (e *Encoder) kInt16(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeInt(int64(*(*int16)(v.ptr)))
+}
+
+func (e *Encoder) kInt32(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeInt(int64(*(*int32)(v.ptr)))
+}
+
+func (e *Encoder) kInt64(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeInt(int64(*(*int64)(v.ptr)))
+}
+
+func (e *Encoder) kUint(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeUint(uint64(*(*uint)(v.ptr)))
+}
+
+func (e *Encoder) kUint8(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeUint(uint64(*(*uint8)(v.ptr)))
+}
+
+func (e *Encoder) kUint16(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeUint(uint64(*(*uint16)(v.ptr)))
+}
+
+func (e *Encoder) kUint32(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeUint(uint64(*(*uint32)(v.ptr)))
+}
+
+func (e *Encoder) kUint64(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeUint(uint64(*(*uint64)(v.ptr)))
+}
+
+func (e *Encoder) kUintptr(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeUint(uint64(*(*uintptr)(v.ptr)))
+}
+
+// ------------
 
 // func rt2id(rt reflect.Type) uintptr {
 // 	return uintptr(((*unsafeIntf)(unsafe.Pointer(&rt))).word)
@@ -455,8 +536,3 @@ func (f *decFnInfo) kUint64(rv reflect.Value) {
 // 	return *(*interface{})(unsafe.Pointer(&ui))
 // 	// return i
 // }
-
-// func i2rv(i interface{}) reflect.Value {
-// 	// u := *(*unsafeIntf)(unsafe.Pointer(&i))
-// 	return reflect.ValueOf(i)
-// }
diff --git a/vendor/github.com/ugorji/go/codec/json.go b/vendor/github.com/ugorji/go/codec/json.go
index 06e882d4c..72c0faf04 100644
--- a/vendor/github.com/ugorji/go/codec/json.go
+++ b/vendor/github.com/ugorji/go/codec/json.go
@@ -34,46 +34,63 @@ package codec
 import (
 	"bytes"
 	"encoding/base64"
+	"math"
 	"reflect"
 	"strconv"
+	"time"
+	"unicode"
 	"unicode/utf16"
 	"unicode/utf8"
 )
 
 //--------------------------------
 
+var jsonLiterals = [...]byte{
+	'"',
+	't', 'r', 'u', 'e',
+	'"',
+	'"',
+	'f', 'a', 'l', 's', 'e',
+	'"',
+	'"',
+	'n', 'u', 'l', 'l',
+	'"',
+}
+
+const (
+	jsonLitTrueQ  = 0
+	jsonLitTrue   = 1
+	jsonLitFalseQ = 6
+	jsonLitFalse  = 7
+	jsonLitNullQ  = 13
+	jsonLitNull   = 14
+)
+
 var (
-	jsonLiterals = [...]byte{'t', 'r', 'u', 'e', 'f', 'a', 'l', 's', 'e', 'n', 'u', 'l', 'l'}
+	// jsonFloat64Pow10 = [...]float64{
+	// 	1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
+	// 	1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
+	// 	1e20, 1e21, 1e22,
+	// }
 
-	jsonFloat64Pow10 = [...]float64{
-		1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
-		1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
-		1e20, 1e21, 1e22,
-	}
-
-	jsonUint64Pow10 = [...]uint64{
-		1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
-		1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
-	}
+	// jsonUint64Pow10 = [...]uint64{
+	// 	1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
+	// 	1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
+	// }
 
 	// jsonTabs and jsonSpaces are used as caches for indents
 	jsonTabs, jsonSpaces string
 
-	jsonCharHtmlSafeSet   [utf8.RuneSelf]bool
-	jsonCharSafeSet       [utf8.RuneSelf]bool
-	jsonCharWhitespaceSet [256]bool
-	jsonNumSet            [256]bool
+	jsonCharHtmlSafeSet   bitset128
+	jsonCharSafeSet       bitset128
+	jsonCharWhitespaceSet bitset256
+	jsonNumSet            bitset256
+	// jsonIsFloatSet        bitset256
+
+	jsonU4Set [256]byte
 )
 
 const (
-	// jsonUnreadAfterDecNum controls whether we unread after decoding a number.
-	//
-	// instead of unreading, just update d.tok (iff it's not a whitespace char)
-	// However, doing this means that we may HOLD onto some data which belongs to another stream.
-	// Thus, it is safest to unread the data when done.
-	// keep behind a constant flag for now.
-	jsonUnreadAfterDecNum = true
-
 	// If !jsonValidateSymbols, decoding will be faster, by skipping some checks:
 	//   - If we see first character of null, false or true,
 	//     do not validate subsequent characters.
@@ -83,6 +100,10 @@ const (
 	jsonValidateSymbols = true
 
 	jsonSpacesOrTabsLen = 128
+
+	jsonU4SetErrVal = 128
+
+	jsonAlwaysReturnInternString = false
 )
 
 func init() {
@@ -100,42 +121,62 @@ func init() {
 	// populate the safe values as true: note: ASCII control characters are (0-31)
 	// jsonCharSafeSet:     all true except (0-31) " \
 	// jsonCharHtmlSafeSet: all true except (0-31) " \ < > &
-	for i := 32; i < utf8.RuneSelf; i++ {
+	var i byte
+	for i = 32; i < utf8.RuneSelf; i++ {
 		switch i {
 		case '"', '\\':
-			jsonCharSafeSet[i] = false
-			jsonCharHtmlSafeSet[i] = false
 		case '<', '>', '&':
-			jsonCharHtmlSafeSet[i] = false
-			jsonCharSafeSet[i] = true
+			jsonCharSafeSet.set(i) // = true
 		default:
-			jsonCharSafeSet[i] = true
-			jsonCharHtmlSafeSet[i] = true
+			jsonCharSafeSet.set(i)
+			jsonCharHtmlSafeSet.set(i)
 		}
 	}
-	for i := 0; i < 256; i++ {
+	for i = 0; i <= utf8.RuneSelf; i++ {
 		switch i {
 		case ' ', '\t', '\r', '\n':
-			jsonCharWhitespaceSet[i] = true
+			jsonCharWhitespaceSet.set(i)
 		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'e', 'E', '.', '+', '-':
-			jsonNumSet[i] = true
+			jsonNumSet.set(i)
 		}
 	}
+	for j := range jsonU4Set {
+		switch i = byte(j); i {
+		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+			jsonU4Set[i] = i - '0'
+		case 'a', 'b', 'c', 'd', 'e', 'f':
+			jsonU4Set[i] = i - 'a' + 10
+		case 'A', 'B', 'C', 'D', 'E', 'F':
+			jsonU4Set[i] = i - 'A' + 10
+		default:
+			jsonU4Set[i] = jsonU4SetErrVal
+		}
+		// switch i = byte(j); i {
+		// case 'e', 'E', '.':
+		// 	jsonIsFloatSet.set(i)
+		// }
+	}
+	// jsonU4Set[255] = jsonU4SetErrVal
 }
 
 type jsonEncDriver struct {
-	e  *Encoder
-	w  encWriter
-	h  *JsonHandle
-	b  [64]byte // scratch
-	bs []byte   // scratch
-	se setExtWrapper
-	ds string // indent string
-	dl uint16 // indent level
-	dt bool   // indent using tabs
-	d  bool   // indent
-	c  containerState
 	noBuiltInTypes
+	e  *Encoder
+	h  *JsonHandle
+	w  encWriter // encWriter // *encWriterSwitch
+	se setExtWrapper
+	// ---- cpu cache line boundary?
+	ds string // indent string
+	d  bool   // indent
+	dt bool   // indent using tabs
+
+	// ---- writable fields during execution --- *try* to keep in sep cache line
+
+	c  containerState
+	dl uint16 // indent level
+	bs []byte // scratch
+	// ---- cpu cache line boundary?
+	b [64]byte // scratch
 }
 
 // indent is done as below:
@@ -143,46 +184,71 @@ type jsonEncDriver struct {
 //   - newline and indent are added before each ending,
 //     except there was no entry (so we can have {} or [])
 
-func (e *jsonEncDriver) sendContainerState(c containerState) {
-	// determine whether to output separators
-	if c == containerMapKey {
-		if e.c != containerMapStart {
-			e.w.writen1(',')
-		}
-		if e.d {
-			e.writeIndent()
-		}
-	} else if c == containerMapValue {
-		if e.d {
-			e.w.writen2(':', ' ')
-		} else {
-			e.w.writen1(':')
-		}
-	} else if c == containerMapEnd {
-		if e.d {
-			e.dl--
-			if e.c != containerMapStart {
-				e.writeIndent()
-			}
-		}
-		e.w.writen1('}')
-	} else if c == containerArrayElem {
-		if e.c != containerArrayStart {
-			e.w.writen1(',')
-		}
-		if e.d {
-			e.writeIndent()
-		}
-	} else if c == containerArrayEnd {
-		if e.d {
-			e.dl--
-			if e.c != containerArrayStart {
-				e.writeIndent()
-			}
-		}
-		e.w.writen1(']')
+func (e *jsonEncDriver) WriteArrayStart(length int) {
+	if e.d {
+		e.dl++
 	}
-	e.c = c
+	e.w.writen1('[')
+	e.c = containerArrayStart
+}
+
+func (e *jsonEncDriver) WriteArrayElem() {
+	if e.c != containerArrayStart {
+		e.w.writen1(',')
+	}
+	if e.d {
+		e.writeIndent()
+	}
+	e.c = containerArrayElem
+}
+
+func (e *jsonEncDriver) WriteArrayEnd() {
+	if e.d {
+		e.dl--
+		if e.c != containerArrayStart {
+			e.writeIndent()
+		}
+	}
+	e.w.writen1(']')
+	e.c = containerArrayEnd
+}
+
+func (e *jsonEncDriver) WriteMapStart(length int) {
+	if e.d {
+		e.dl++
+	}
+	e.w.writen1('{')
+	e.c = containerMapStart
+}
+
+func (e *jsonEncDriver) WriteMapElemKey() {
+	if e.c != containerMapStart {
+		e.w.writen1(',')
+	}
+	if e.d {
+		e.writeIndent()
+	}
+	e.c = containerMapKey
+}
+
+func (e *jsonEncDriver) WriteMapElemValue() {
+	if e.d {
+		e.w.writen2(':', ' ')
+	} else {
+		e.w.writen1(':')
+	}
+	e.c = containerMapValue
+}
+
+func (e *jsonEncDriver) WriteMapEnd() {
+	if e.d {
+		e.dl--
+		if e.c != containerMapStart {
+			e.writeIndent()
+		}
+	}
+	e.w.writen1('}')
+	e.c = containerMapEnd
 }
 
 func (e *jsonEncDriver) writeIndent() {
@@ -201,51 +267,141 @@ func (e *jsonEncDriver) writeIndent() {
 }
 
 func (e *jsonEncDriver) EncodeNil() {
-	e.w.writeb(jsonLiterals[9:13]) // null
+	// We always encode nil as just null (never in quotes)
+	// This allows us to easily decode if a nil in the json stream
+	// ie if initial token is n.
+	e.w.writeb(jsonLiterals[jsonLitNull : jsonLitNull+4])
+
+	// if e.h.MapKeyAsString && e.c == containerMapKey {
+	// 	e.w.writeb(jsonLiterals[jsonLitNullQ : jsonLitNullQ+6])
+	// } else {
+	// 	e.w.writeb(jsonLiterals[jsonLitNull : jsonLitNull+4])
+	// }
+}
+
+func (e *jsonEncDriver) EncodeTime(t time.Time) {
+	// Do NOT use MarshalJSON, as it allocates internally.
+	// instead, we call AppendFormat directly, using our scratch buffer (e.b)
+	if t.IsZero() {
+		e.EncodeNil()
+	} else {
+		e.b[0] = '"'
+		b := t.AppendFormat(e.b[1:1], time.RFC3339Nano)
+		e.b[len(b)+1] = '"'
+		e.w.writeb(e.b[:len(b)+2])
+	}
+	// fmt.Printf(">>>> time as a string: '%s'\n", e.b[:len(b)+2])
+	// v, err := t.MarshalJSON(); if err != nil { e.e.error(err) } e.w.writeb(v)
 }
 
 func (e *jsonEncDriver) EncodeBool(b bool) {
-	if b {
-		e.w.writeb(jsonLiterals[0:4]) // true
+	if e.h.MapKeyAsString && e.c == containerMapKey {
+		if b {
+			e.w.writeb(jsonLiterals[jsonLitTrueQ : jsonLitTrueQ+6])
+		} else {
+			e.w.writeb(jsonLiterals[jsonLitFalseQ : jsonLitFalseQ+7])
+		}
 	} else {
-		e.w.writeb(jsonLiterals[4:9]) // false
+		if b {
+			e.w.writeb(jsonLiterals[jsonLitTrue : jsonLitTrue+4])
+		} else {
+			e.w.writeb(jsonLiterals[jsonLitFalse : jsonLitFalse+5])
+		}
 	}
 }
 
 func (e *jsonEncDriver) EncodeFloat32(f float32) {
-	e.encodeFloat(float64(f), 32)
+	// e.encodeFloat(float64(f), 32)
+	e.EncodeFloat64(float64(f))
 }
 
 func (e *jsonEncDriver) EncodeFloat64(f float64) {
-	// e.w.writestr(strconv.FormatFloat(f, 'E', -1, 64))
-	e.encodeFloat(f, 64)
+	var blen int
+	// instead of using 'g', specify whether to use 'e' or 'f'
+	var abs = math.Abs(f)
+	var fmt byte
+	var prec int = -1
+	if abs != 0 && (abs < 1e-6 || abs >= 1e21) {
+		fmt = 'e'
+	} else {
+		fmt = 'f'
+		// set prec to 1 iff mod is 0.
+		//     better than using jsonIsFloatBytesB2 to check if a . or E in the float bytes.
+		// this ensures that every float has an e or .0 in it.
+		if abs <= 1 {
+			if abs == 0 || abs == 1 {
+				prec = 1
+			}
+		} else if _, mod := math.Modf(abs); mod == 0 {
+			prec = 1
+		}
+	}
+
+	if e.h.MapKeyAsString && e.c == containerMapKey {
+		blen = 2 + len(strconv.AppendFloat(e.b[1:1], f, fmt, prec, 64))
+		e.b[0] = '"'
+		e.b[blen-1] = '"'
+	} else {
+		blen = len(strconv.AppendFloat(e.b[:0], f, fmt, prec, 64))
+	}
+	e.w.writeb(e.b[:blen])
 }
 
-func (e *jsonEncDriver) encodeFloat(f float64, numbits int) {
-	x := strconv.AppendFloat(e.b[:0], f, 'G', -1, numbits)
-	e.w.writeb(x)
-	if bytes.IndexByte(x, 'E') == -1 && bytes.IndexByte(x, '.') == -1 {
-		e.w.writen2('.', '0')
-	}
-}
+// func (e *jsonEncDriver) EncodeFloat64(f float64) {
+// 	e.encodeFloat(f, 64)
+// }
+
+// func (e *jsonEncDriver) encodeFloat(f float64, bits int) {
+// 	var blen int
+// 	// instead of using 'g', specify whether to use 'e' or 'f'
+// 	var abs = math.Abs(f)
+// 	var fmt byte
+// 	var prec int = -1
+// 	if abs != 0 && (bits == 64 && (abs < 1e-6 || abs >= 1e21) || bits == 32 && (float32(abs) < 1e-6 || float32(abs) >= 1e21)) {
+// 		fmt = 'e'
+// 	} else {
+// 		fmt = 'f'
+// 		// set prec to 1 iff mod is 0.
+// 		//     better than using jsonIsFloatBytesB2 to check if a . or E in the float bytes.
+// 		// this ensures that every float has an e or .0 in it.
+// 		if abs <= 1 {
+// 			if abs == 0 || abs == 1 {
+// 				prec = 1
+// 			}
+// 		} else if _, mod := math.Modf(abs); mod == 0 {
+// 			prec = 1
+// 		}
+// 	}
+
+// 	if e.h.MapKeyAsString && e.c == containerMapKey {
+// 		blen = 2 + len(strconv.AppendFloat(e.b[1:1], f, fmt, prec, bits))
+// 		e.b[0] = '"'
+// 		e.b[blen-1] = '"'
+// 	} else {
+// 		blen = len(strconv.AppendFloat(e.b[:0], f, fmt, prec, bits))
+// 	}
+// 	e.w.writeb(e.b[:blen])
+// }
 
 func (e *jsonEncDriver) EncodeInt(v int64) {
-	// if e.h.IntegerAsString == 'A' || e.h.IntegerAsString == 'L' && (v > 1<<53 || v < -(1<<53)) {
-	if x := e.h.IntegerAsString; x == 'A' || x == 'L' && (v > 1<<53 || v < -(1<<53)) {
-		e.w.writen1('"')
-		e.w.writeb(strconv.AppendInt(e.b[:0], v, 10))
-		e.w.writen1('"')
+	x := e.h.IntegerAsString
+	if x == 'A' || x == 'L' && (v > 1<<53 || v < -(1<<53)) || (e.h.MapKeyAsString && e.c == containerMapKey) {
+		blen := 2 + len(strconv.AppendInt(e.b[1:1], v, 10))
+		e.b[0] = '"'
+		e.b[blen-1] = '"'
+		e.w.writeb(e.b[:blen])
 		return
 	}
 	e.w.writeb(strconv.AppendInt(e.b[:0], v, 10))
 }
 
 func (e *jsonEncDriver) EncodeUint(v uint64) {
-	// if e.h.IntegerAsString == 'A' || e.h.IntegerAsString == 'L' && v > 1<<53 {
-	if x := e.h.IntegerAsString; x == 'A' || x == 'L' && v > 1<<53 {
-		e.w.writen1('"')
-		e.w.writeb(strconv.AppendUint(e.b[:0], v, 10))
-		e.w.writen1('"')
+	x := e.h.IntegerAsString
+	if x == 'A' || x == 'L' && v > 1<<53 || (e.h.MapKeyAsString && e.c == containerMapKey) {
+		blen := 2 + len(strconv.AppendUint(e.b[1:1], v, 10))
+		e.b[0] = '"'
+		e.b[blen-1] = '"'
+		e.w.writeb(e.b[:blen])
 		return
 	}
 	e.w.writeb(strconv.AppendUint(e.b[:0], v, 10))
@@ -253,7 +409,7 @@ func (e *jsonEncDriver) EncodeUint(v uint64) {
 
 func (e *jsonEncDriver) EncodeExt(rv interface{}, xtag uint64, ext Ext, en *Encoder) {
 	if v := ext.ConvertExt(rv); v == nil {
-		e.w.writeb(jsonLiterals[9:13]) // null // e.EncodeNil()
+		e.EncodeNil()
 	} else {
 		en.encode(v)
 	}
@@ -262,45 +418,32 @@ func (e *jsonEncDriver) EncodeExt(rv interface{}, xtag uint64, ext Ext, en *Enco
 func (e *jsonEncDriver) EncodeRawExt(re *RawExt, en *Encoder) {
 	// only encodes re.Value (never re.Data)
 	if re.Value == nil {
-		e.w.writeb(jsonLiterals[9:13]) // null // e.EncodeNil()
+		e.EncodeNil()
 	} else {
 		en.encode(re.Value)
 	}
 }
 
-func (e *jsonEncDriver) EncodeArrayStart(length int) {
-	if e.d {
-		e.dl++
-	}
-	e.w.writen1('[')
-	e.c = containerArrayStart
-}
-
-func (e *jsonEncDriver) EncodeMapStart(length int) {
-	if e.d {
-		e.dl++
-	}
-	e.w.writen1('{')
-	e.c = containerMapStart
-}
-
 func (e *jsonEncDriver) EncodeString(c charEncoding, v string) {
-	// e.w.writestr(strconv.Quote(v))
 	e.quoteStr(v)
 }
 
 func (e *jsonEncDriver) EncodeSymbol(v string) {
-	// e.EncodeString(c_UTF8, v)
 	e.quoteStr(v)
 }
 
 func (e *jsonEncDriver) EncodeStringBytes(c charEncoding, v []byte) {
 	// if encoding raw bytes and RawBytesExt is configured, use it to encode
-	if c == c_RAW && e.se.i != nil {
-		e.EncodeExt(v, 0, &e.se, e.e)
+	if v == nil {
+		e.EncodeNil()
 		return
 	}
-	if c == c_RAW {
+	if c == cRAW {
+		if e.se.i != nil {
+			e.EncodeExt(v, 0, &e.se, e.e)
+			return
+		}
+
 		slen := base64.StdEncoding.EncodedLen(len(v))
 		if cap(e.bs) >= slen {
 			e.bs = e.bs[:slen]
@@ -312,7 +455,6 @@ func (e *jsonEncDriver) EncodeStringBytes(c charEncoding, v []byte) {
 		e.w.writeb(e.bs)
 		e.w.writen1('"')
 	} else {
-		// e.EncodeString(c, string(v))
 		e.quoteStr(stringView(v))
 	}
 }
@@ -326,13 +468,13 @@ func (e *jsonEncDriver) quoteStr(s string) {
 	const hex = "0123456789abcdef"
 	w := e.w
 	w.writen1('"')
-	start := 0
-	for i := 0; i < len(s); {
+	var start int
+	for i, slen := 0, len(s); i < slen; {
 		// encode all bytes < 0x20 (except \r, \n).
 		// also encode < > & to prevent security holes when served to some browsers.
 		if b := s[i]; b < utf8.RuneSelf {
 			// if 0x20 <= b && b != '\\' && b != '"' && b != '<' && b != '>' && b != '&' {
-			if jsonCharHtmlSafeSet[b] || (e.h.HTMLCharsAsIs && jsonCharSafeSet[b]) {
+			if jsonCharHtmlSafeSet.isset(b) || (e.h.HTMLCharsAsIs && jsonCharSafeSet.isset(b)) {
 				i++
 				continue
 			}
@@ -390,30 +532,42 @@ func (e *jsonEncDriver) quoteStr(s string) {
 	w.writen1('"')
 }
 
+func (e *jsonEncDriver) atEndOfEncode() {
+	if e.h.TermWhitespace {
+		if e.d {
+			e.w.writen1('\n')
+		} else {
+			e.w.writen1(' ')
+		}
+	}
+}
+
 type jsonDecDriver struct {
 	noBuiltInTypes
-	d *Decoder
-	h *JsonHandle
-	r decReader
+	d  *Decoder
+	h  *JsonHandle
+	r  decReader // *decReaderSwitch // decReader
+	se setExtWrapper
+
+	// ---- writable fields during execution --- *try* to keep in sep cache line
 
 	c containerState
 	// tok is used to store the token read right after skipWhiteSpace.
-	tok uint8
-
-	bstr [8]byte  // scratch used for string \UXXX parsing
-	b    [64]byte // scratch, used for parsing strings or numbers
-	b2   [64]byte // scratch, used only for decodeBytes (after base64)
-	bs   []byte   // scratch. Initialized from b. Used for parsing strings or numbers.
-
-	se setExtWrapper
+	tok   uint8
+	fnull bool    // found null from appendStringAsBytes
+	bs    []byte  // scratch. Initialized from b. Used for parsing strings or numbers.
+	bstr  [8]byte // scratch used for string \UXXX parsing
+	// ---- cpu cache line boundary?
+	b  [64]byte // scratch 1, used for parsing strings or numbers or time.Time
+	b2 [64]byte // scratch 2, used only for readUntil, decNumBytes
 
 	// n jsonNum
 }
 
-func jsonIsWS(b byte) bool {
-	// return b == ' ' || b == '\t' || b == '\r' || b == '\n'
-	return jsonCharWhitespaceSet[b]
-}
+// func jsonIsWS(b byte) bool {
+// 	// return b == ' ' || b == '\t' || b == '\r' || b == '\n'
+// 	return jsonCharWhitespaceSet.isset(b)
+// }
 
 func (d *jsonDecDriver) uncacheRead() {
 	if d.tok != 0 {
@@ -422,84 +576,13 @@ func (d *jsonDecDriver) uncacheRead() {
 	}
 }
 
-func (d *jsonDecDriver) sendContainerState(c containerState) {
-	if d.tok == 0 {
-		d.tok = d.r.skip(&jsonCharWhitespaceSet)
-	}
-	var xc uint8 // char expected
-	if c == containerMapKey {
-		if d.c != containerMapStart {
-			xc = ','
-		}
-	} else if c == containerMapValue {
-		xc = ':'
-	} else if c == containerMapEnd {
-		xc = '}'
-	} else if c == containerArrayElem {
-		if d.c != containerArrayStart {
-			xc = ','
-		}
-	} else if c == containerArrayEnd {
-		xc = ']'
-	}
-	if xc != 0 {
-		if d.tok != xc {
-			d.d.errorf("json: expect char '%c' but got char '%c'", xc, d.tok)
-		}
-		d.tok = 0
-	}
-	d.c = c
-}
-
-func (d *jsonDecDriver) CheckBreak() bool {
-	if d.tok == 0 {
-		d.tok = d.r.skip(&jsonCharWhitespaceSet)
-	}
-	return d.tok == '}' || d.tok == ']'
-}
-
-func (d *jsonDecDriver) readStrIdx(fromIdx, toIdx uint8) {
-	bs := d.r.readx(int(toIdx - fromIdx))
-	d.tok = 0
-	if jsonValidateSymbols && !bytes.Equal(bs, jsonLiterals[fromIdx:toIdx]) {
-		d.d.errorf("json: expecting %s: got %s", jsonLiterals[fromIdx:toIdx], bs)
-		return
-	}
-}
-
-func (d *jsonDecDriver) TryDecodeAsNil() bool {
-	if d.tok == 0 {
-		d.tok = d.r.skip(&jsonCharWhitespaceSet)
-	}
-	if d.tok == 'n' {
-		d.readStrIdx(10, 13) // ull
-		return true
-	}
-	return false
-}
-
-func (d *jsonDecDriver) DecodeBool() bool {
-	if d.tok == 0 {
-		d.tok = d.r.skip(&jsonCharWhitespaceSet)
-	}
-	if d.tok == 'f' {
-		d.readStrIdx(5, 9) // alse
-		return false
-	}
-	if d.tok == 't' {
-		d.readStrIdx(1, 4) // rue
-		return true
-	}
-	d.d.errorf("json: decode bool: got first char %c", d.tok)
-	return false // "unreachable"
-}
-
 func (d *jsonDecDriver) ReadMapStart() int {
 	if d.tok == 0 {
 		d.tok = d.r.skip(&jsonCharWhitespaceSet)
 	}
-	if d.tok != '{' {
-		d.d.errorf("json: expect char '%c' but got char '%c'", '{', d.tok)
+	const xc uint8 = '{'
+	if d.tok != xc {
+		d.d.errorf("json: expect char '%c' but got char '%c'", xc, d.tok)
 	}
 	d.tok = 0
 	d.c = containerMapStart
@@ -510,14 +593,159 @@ func (d *jsonDecDriver) ReadArrayStart() int {
 	if d.tok == 0 {
 		d.tok = d.r.skip(&jsonCharWhitespaceSet)
 	}
-	if d.tok != '[' {
-		d.d.errorf("json: expect char '%c' but got char '%c'", '[', d.tok)
+	const xc uint8 = '['
+	if d.tok != xc {
+		d.d.errorf("json: expect char '%c' but got char '%c'", xc, d.tok)
 	}
 	d.tok = 0
 	d.c = containerArrayStart
 	return -1
 }
 
+func (d *jsonDecDriver) CheckBreak() bool {
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	return d.tok == '}' || d.tok == ']'
+}
+
+func (d *jsonDecDriver) ReadArrayElem() {
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	if d.c != containerArrayStart {
+		const xc uint8 = ','
+		if d.tok != xc {
+			d.d.errorf("json: expect char '%c' but got char '%c'", xc, d.tok)
+		}
+		d.tok = 0
+	}
+	d.c = containerArrayElem
+}
+
+func (d *jsonDecDriver) ReadArrayEnd() {
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	const xc uint8 = ']'
+	if d.tok != xc {
+		d.d.errorf("json: expect char '%c' but got char '%c'", xc, d.tok)
+	}
+	d.tok = 0
+	d.c = containerArrayEnd
+}
+
+func (d *jsonDecDriver) ReadMapElemKey() {
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	if d.c != containerMapStart {
+		const xc uint8 = ','
+		if d.tok != xc {
+			d.d.errorf("json: expect char '%c' but got char '%c'", xc, d.tok)
+		}
+		d.tok = 0
+	}
+	d.c = containerMapKey
+}
+
+func (d *jsonDecDriver) ReadMapElemValue() {
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	const xc uint8 = ':'
+	if d.tok != xc {
+		d.d.errorf("json: expect char '%c' but got char '%c'", xc, d.tok)
+	}
+	d.tok = 0
+	d.c = containerMapValue
+}
+
+func (d *jsonDecDriver) ReadMapEnd() {
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	const xc uint8 = '}'
+	if d.tok != xc {
+		d.d.errorf("json: expect char '%c' but got char '%c'", xc, d.tok)
+	}
+	d.tok = 0
+	d.c = containerMapEnd
+}
+
+// func (d *jsonDecDriver) readContainerState(c containerState, xc uint8, check bool) {
+// 	if d.tok == 0 {
+// 		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+// 	}
+// 	if check {
+// 		if d.tok != xc {
+// 			d.d.errorf("json: expect char '%c' but got char '%c'", xc, d.tok)
+// 		}
+// 		d.tok = 0
+// 	}
+// 	d.c = c
+// }
+
+func (d *jsonDecDriver) readLit(length, fromIdx uint8) {
+	bs := d.r.readx(int(length))
+	d.tok = 0
+	if jsonValidateSymbols && !bytes.Equal(bs, jsonLiterals[fromIdx:fromIdx+length]) {
+		d.d.errorf("json: expecting %s: got %s", jsonLiterals[fromIdx:fromIdx+length], bs)
+		return
+	}
+}
+
+func (d *jsonDecDriver) TryDecodeAsNil() bool {
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	// we shouldn't try to see if "null" was here, right?
+	// only the plain string: `null` denotes a nil (ie not quotes)
+	if d.tok == 'n' {
+		d.readLit(3, jsonLitNull+1) // (n)ull
+		return true
+	}
+	return false
+}
+
+func (d *jsonDecDriver) DecodeBool() (v bool) {
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	fquot := d.c == containerMapKey && d.tok == '"'
+	if fquot {
+		d.tok = d.r.readn1()
+	}
+	switch d.tok {
+	case 'f':
+		d.readLit(4, jsonLitFalse+1) // (f)alse
+		// v = false
+	case 't':
+		d.readLit(3, jsonLitTrue+1) // (t)rue
+		v = true
+	default:
+		d.d.errorf("json: decode bool: got first char %c", d.tok)
+		// v = false // "unreachable"
+	}
+	if fquot {
+		d.r.readn1()
+	}
+	return
+}
+
+func (d *jsonDecDriver) DecodeTime() (t time.Time) {
+	// read string, and pass the string into json.unmarshal
+	d.appendStringAsBytes()
+	if d.fnull {
+		return
+	}
+	t, err := time.Parse(time.RFC3339, stringView(d.bs))
+	if err != nil {
+		d.d.errorv(err)
+	}
+	return
+}
+
 func (d *jsonDecDriver) ContainerType() (vt valueType) {
 	// check container type by checking the first char
 	if d.tok == 0 {
@@ -548,10 +776,8 @@ func (d *jsonDecDriver) decNumBytes() (bs []byte) {
 	} else {
 		d.r.unreadn1()
 		bs = d.r.readTo(d.bs[:0], &jsonNumSet)
-		// bs = d.r.readbUntilAny(d.bs[:0], " \t\n:,{}[]")
 	}
 	d.tok = 0
-	// fmt.Printf(">>>> decNumBytes: returning: '%s'\n", bs)
 	return bs
 }
 
@@ -567,28 +793,18 @@ func (d *jsonDecDriver) DecodeUint(bitsize uint8) (u uint64) {
 
 func (d *jsonDecDriver) DecodeInt(bitsize uint8) (i int64) {
 	bs := d.decNumBytes()
-	// if bytes.ContainsAny(bs, ".eE") {
-	// 	d.d.errorf("json: decoding int, but found one or more of the chars: .eE: %s", bs)
-	// 	return
-	// }
 	i, err := strconv.ParseInt(stringView(bs), 10, int(bitsize))
 	if err != nil {
-		d.d.errorf("json: decode int from %s: %v", bs, err)
-		return
+		d.d.errorv(err)
 	}
 	return
 }
 
-func (d *jsonDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) {
+func (d *jsonDecDriver) DecodeFloat64() (f float64) {
 	bs := d.decNumBytes()
-	bitsize := 64
-	if chkOverflow32 {
-		bitsize = 32
-	}
-	f, err := strconv.ParseFloat(stringView(bs), bitsize)
+	f, err := strconv.ParseFloat(stringView(bs), 64)
 	if err != nil {
-		d.d.errorf("json: decode float from %s: %v", bs, err)
-		return
+		d.d.errorv(err)
 	}
 	return
 }
@@ -613,11 +829,24 @@ func (d *jsonDecDriver) DecodeBytes(bs []byte, zerocopy bool) (bsOut []byte) {
 		d.DecodeExt(&bsOut, 0, &d.se)
 		return
 	}
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	// check if an "array" of uint8's (see ContainerType for how to infer if an array)
+	if d.tok == '[' {
+		bsOut, _ = fastpathTV.DecSliceUint8V(bs, true, d.d)
+		return
+	}
 	d.appendStringAsBytes()
-	// if appendStringAsBytes returned a zero-len slice, then treat as nil.
-	// This should only happen for null, and "".
+	// base64 encodes []byte{} as "", and we encode nil []byte as null.
+	// Consequently, base64 should decode null as a nil []byte, and "" as an empty []byte{}.
+	// appendStringAsBytes returns a zero-len slice for both, so as not to reset d.bs.
+	// However, it sets a fnull field to true, so we can check if a null was found.
 	if len(d.bs) == 0 {
-		return nil
+		if d.fnull {
+			return nil
+		}
+		return []byte{}
 	}
 	bs0 := d.bs
 	slen := base64.StdEncoding.DecodedLen(len(bs0))
@@ -639,15 +868,9 @@ func (d *jsonDecDriver) DecodeBytes(bs []byte, zerocopy bool) (bsOut []byte) {
 	return
 }
 
-const jsonAlwaysReturnInternString = false
-
 func (d *jsonDecDriver) DecodeString() (s string) {
 	d.appendStringAsBytes()
-	// if x := d.s.sc; x != nil && x.so && x.st == '}' { // map key
-	if jsonAlwaysReturnInternString || d.c == containerMapKey {
-		return d.d.string(d.bs)
-	}
-	return string(d.bs)
+	return d.bsToString()
 }
 
 func (d *jsonDecDriver) DecodeStringAsBytes() (s []byte) {
@@ -660,25 +883,31 @@ func (d *jsonDecDriver) appendStringAsBytes() {
 		d.tok = d.r.skip(&jsonCharWhitespaceSet)
 	}
 
+	d.fnull = false
 	if d.tok != '"' {
 		// d.d.errorf("json: expect char '%c' but got char '%c'", '"', d.tok)
 		// handle non-string scalar: null, true, false or a number
 		switch d.tok {
 		case 'n':
-			d.readStrIdx(10, 13) // ull
+			d.readLit(3, jsonLitNull+1) // (n)ull
 			d.bs = d.bs[:0]
+			d.fnull = true
 		case 'f':
-			d.readStrIdx(5, 9) // alse
+			d.readLit(4, jsonLitFalse+1) // (f)alse
 			d.bs = d.bs[:5]
 			copy(d.bs, "false")
 		case 't':
-			d.readStrIdx(1, 4) // rue
+			d.readLit(3, jsonLitTrue+1) // (t)rue
 			d.bs = d.bs[:4]
 			copy(d.bs, "true")
 		default:
 			// try to parse a valid number
 			bs := d.decNumBytes()
-			d.bs = d.bs[:len(bs)]
+			if len(bs) <= cap(d.bs) {
+				d.bs = d.bs[:len(bs)]
+			} else {
+				d.bs = make([]byte, len(bs))
+			}
 			copy(d.bs, bs)
 		}
 		return
@@ -686,26 +915,38 @@ func (d *jsonDecDriver) appendStringAsBytes() {
 
 	d.tok = 0
 	r := d.r
-	var cs []byte
+	var cs = r.readUntil(d.b2[:0], '"')
+	var cslen = len(cs)
+	var c uint8
 	v := d.bs[:0]
-	// var c uint8
-	for i := 0; ; i++ {
-		if i == len(cs) {
+	// append on each byte seen can be expensive, so we just
+	// keep track of where we last read a contiguous set of
+	// non-special bytes (using cursor variable),
+	// and when we see a special byte
+	// e.g. end-of-slice, " or \,
+	// we will append the full range into the v slice before proceeding
+	for i, cursor := 0, 0; ; {
+		if i == cslen {
+			v = append(v, cs[cursor:]...)
 			cs = r.readUntil(d.b2[:0], '"')
-			i = 0
+			cslen = len(cs)
+			i, cursor = 0, 0
 		}
-		if cs[i] == '"' {
+		c = cs[i]
+		if c == '"' {
+			v = append(v, cs[cursor:i]...)
 			break
 		}
-		if cs[i] != '\\' {
-			v = append(v, cs[i])
+		if c != '\\' {
+			i++
 			continue
 		}
-		// cs[i] == '\\'
+		v = append(v, cs[cursor:i]...)
 		i++
-		switch cs[i] {
+		c = cs[i]
+		switch c {
 		case '"', '\\', '/', '\'':
-			v = append(v, cs[i])
+			v = append(v, c)
 		case 'b':
 			v = append(v, '\b')
 		case 'f':
@@ -717,50 +958,89 @@ func (d *jsonDecDriver) appendStringAsBytes() {
 		case 't':
 			v = append(v, '\t')
 		case 'u':
-			rr := d.jsonU4Arr([4]byte{cs[i+1], cs[i+2], cs[i+3], cs[i+4]})
-			i += 4
-			// fmt.Printf("$$$$$$$$$: is surrogate: %v\n", utf16.IsSurrogate(rr))
-			if utf16.IsSurrogate(rr) {
-				// fmt.Printf(">>>> checking utf16 surrogate\n")
-				if !(cs[i+1] == '\\' && cs[i+2] == 'u') {
-					d.d.errorf(`json: unquoteStr: invalid unicode sequence. Expecting \u`)
-					return
-				}
-				i += 2
-				rr = utf16.DecodeRune(rr, d.jsonU4Arr([4]byte{cs[i+1], cs[i+2], cs[i+3], cs[i+4]}))
-				i += 4
+			var r rune
+			var rr uint32
+			if len(cs) < i+4 { // may help reduce bounds-checking
+				d.d.errorf(`json: need at least 4 more bytes for unicode sequence`)
 			}
-			w2 := utf8.EncodeRune(d.bstr[:], rr)
+			// c = cs[i+4] // may help reduce bounds-checking
+			for j := 1; j < 5; j++ {
+				c = jsonU4Set[cs[i+j]]
+				if c == jsonU4SetErrVal {
+					// d.d.errorf(`json: unquoteStr: invalid hex char in \u unicode sequence: %q`, c)
+					r = unicode.ReplacementChar
+					i += 4
+					goto encode_rune
+				}
+				rr = rr*16 + uint32(c)
+			}
+			r = rune(rr)
+			i += 4
+			if utf16.IsSurrogate(r) {
+				if len(cs) >= i+6 && cs[i+2] == 'u' && cs[i+1] == '\\' {
+					i += 2
+					// c = cs[i+4] // may help reduce bounds-checking
+					var rr1 uint32
+					for j := 1; j < 5; j++ {
+						c = jsonU4Set[cs[i+j]]
+						if c == jsonU4SetErrVal {
+							// d.d.errorf(`json: unquoteStr: invalid hex char in \u unicode sequence: %q`, c)
+							r = unicode.ReplacementChar
+							i += 4
+							goto encode_rune
+						}
+						rr1 = rr1*16 + uint32(c)
+					}
+					r = utf16.DecodeRune(r, rune(rr1))
+					i += 4
+				} else {
+					r = unicode.ReplacementChar
+					goto encode_rune
+				}
+			}
+		encode_rune:
+			w2 := utf8.EncodeRune(d.bstr[:], r)
 			v = append(v, d.bstr[:w2]...)
 		default:
-			d.d.errorf("json: unsupported escaped value: %c", cs[i])
+			d.d.errorf("json: unsupported escaped value: %c", c)
 		}
+		i++
+		cursor = i
 	}
 	d.bs = v
 }
 
-func (d *jsonDecDriver) jsonU4Arr(bs [4]byte) (r rune) {
-	// u, _ := strconv.ParseUint(string(d.bstr[:4]), 16, 64)
-	var u uint32
-	for _, v := range bs {
-		if '0' <= v && v <= '9' {
-			v = v - '0'
-		} else if 'a' <= v && v <= 'z' {
-			v = v - 'a' + 10
-		} else if 'A' <= v && v <= 'Z' {
-			v = v - 'A' + 10
-		} else {
-			d.d.errorf(`json: unquoteStr: invalid hex char in \u unicode sequence: %q`, v)
-			return 0
-		}
-		u = u*16 + uint32(v)
+func (d *jsonDecDriver) nakedNum(z *decNaked, bs []byte) (err error) {
+	if d.h.PreferFloat || jsonIsFloatBytesB3(bs) { // bytes.IndexByte(bs, '.') != -1 ||...
+		// } else if d.h.PreferFloat || bytes.ContainsAny(bs, ".eE") {
+		z.v = valueTypeFloat
+		z.f, err = strconv.ParseFloat(stringView(bs), 64)
+	} else if d.h.SignedInteger || bs[0] == '-' {
+		z.v = valueTypeInt
+		z.i, err = strconv.ParseInt(stringView(bs), 10, 64)
+	} else {
+		z.v = valueTypeUint
+		z.u, err = strconv.ParseUint(stringView(bs), 10, 64)
 	}
-	// fmt.Printf(">>>>>>>> jsonU4Arr: %v, %s\n", rune(u), string(rune(u)))
-	return rune(u)
+	if err != nil && z.v != valueTypeFloat {
+		if v, ok := err.(*strconv.NumError); ok && (v.Err == strconv.ErrRange || v.Err == strconv.ErrSyntax) {
+			z.v = valueTypeFloat
+			z.f, err = strconv.ParseFloat(stringView(bs), 64)
+		}
+	}
+	return
+}
+
+func (d *jsonDecDriver) bsToString() string {
+	// if x := d.s.sc; x != nil && x.so && x.st == '}' { // map key
+	if jsonAlwaysReturnInternString || d.c == containerMapKey {
+		return d.d.string(d.bs)
+	}
+	return string(d.bs)
 }
 
 func (d *jsonDecDriver) DecodeNaked() {
-	z := &d.d.n
+	z := d.d.n
 	// var decodeFurther bool
 
 	if d.tok == 0 {
@@ -768,60 +1048,54 @@ func (d *jsonDecDriver) DecodeNaked() {
 	}
 	switch d.tok {
 	case 'n':
-		d.readStrIdx(10, 13) // ull
+		d.readLit(3, jsonLitNull+1) // (n)ull
 		z.v = valueTypeNil
 	case 'f':
-		d.readStrIdx(5, 9) // alse
+		d.readLit(4, jsonLitFalse+1) // (f)alse
 		z.v = valueTypeBool
 		z.b = false
 	case 't':
-		d.readStrIdx(1, 4) // rue
+		d.readLit(3, jsonLitTrue+1) // (t)rue
 		z.v = valueTypeBool
 		z.b = true
 	case '{':
-		z.v = valueTypeMap
-		// d.tok = 0 // don't consume. kInterfaceNaked will call ReadMapStart
-		// decodeFurther = true
+		z.v = valueTypeMap // don't consume. kInterfaceNaked will call ReadMapStart
 	case '[':
-		z.v = valueTypeArray
-		// d.tok = 0 // don't consume. kInterfaceNaked will call ReadArrayStart
-		// decodeFurther = true
+		z.v = valueTypeArray // don't consume. kInterfaceNaked will call ReadArrayStart
 	case '"':
-		z.v = valueTypeString
-		z.s = d.DecodeString()
+		// if a string, and MapKeyAsString, then try to decode it as a nil, bool or number first
+		d.appendStringAsBytes()
+		if len(d.bs) > 0 && d.c == containerMapKey && d.h.MapKeyAsString {
+			switch stringView(d.bs) {
+			case "null":
+				z.v = valueTypeNil
+			case "true":
+				z.v = valueTypeBool
+				z.b = true
+			case "false":
+				z.v = valueTypeBool
+				z.b = false
+			default:
+				// check if a number: float, int or uint
+				if err := d.nakedNum(z, d.bs); err != nil {
+					z.v = valueTypeString
+					z.s = d.bsToString()
+				}
+			}
+		} else {
+			z.v = valueTypeString
+			z.s = d.bsToString()
+		}
 	default: // number
 		bs := d.decNumBytes()
-		var err error
 		if len(bs) == 0 {
 			d.d.errorf("json: decode number from empty string")
 			return
-		} else if d.h.PreferFloat ||
-			bytes.IndexByte(bs, '.') != -1 ||
-			bytes.IndexByte(bs, 'e') != -1 ||
-			bytes.IndexByte(bs, 'E') != -1 {
-			// } else if d.h.PreferFloat || bytes.ContainsAny(bs, ".eE") {
-			z.v = valueTypeFloat
-			z.f, err = strconv.ParseFloat(stringView(bs), 64)
-		} else if d.h.SignedInteger || bs[0] == '-' {
-			z.v = valueTypeInt
-			z.i, err = strconv.ParseInt(stringView(bs), 10, 64)
-		} else {
-			z.v = valueTypeUint
-			z.u, err = strconv.ParseUint(stringView(bs), 10, 64)
 		}
-		if err != nil {
-			if z.v == valueTypeInt || z.v == valueTypeUint {
-				if v, ok := err.(*strconv.NumError); ok && (v.Err == strconv.ErrRange || v.Err == strconv.ErrSyntax) {
-					z.v = valueTypeFloat
-					z.f, err = strconv.ParseFloat(stringView(bs), 64)
-				}
-			}
-			if err != nil {
-				d.d.errorf("json: decode number from %s: %v", bs, err)
-				return
-			}
+		if err := d.nakedNum(z, bs); err != nil {
+			d.d.errorf("json: decode number from %s: %v", bs, err)
+			return
 		}
-		// fmt.Printf("DecodeNaked: Number: %T, %v\n", v, v)
 	}
 	// if decodeFurther {
 	// 	d.s.sc.retryRead()
@@ -829,14 +1103,6 @@ func (d *jsonDecDriver) DecodeNaked() {
 	return
 }
 
-// func jsonAcceptNonWS(b byte) bool {
-// 	return !jsonCharWhitespaceSet[b]
-// }
-
-// func jsonAcceptDQuote(b byte) bool {
-// 	return b == '"'
-// }
-
 //----------------------
 
 // JsonHandle is a handle for JSON encoding format.
@@ -855,6 +1121,10 @@ func (d *jsonDecDriver) DecodeNaked() {
 // reading multiple values from a stream containing json and non-json content.
 // For example, a user can read a json value, then a cbor value, then a msgpack value,
 // all from the same stream in sequence.
+//
+// Note that, when decoding quoted strings, invalid UTF-8 or invalid UTF-16 surrogate pairs
+// are not treated as an error.
+// Instead, they are replaced by the Unicode replacement character U+FFFD.
 type JsonHandle struct {
 	textEncodingType
 	BasicHandle
@@ -891,8 +1161,27 @@ type JsonHandle struct {
 	// If not set, we will examine the characters of the number and decode as an
 	// integer type if it doesn't have any of the characters [.eE].
 	PreferFloat bool
+
+	// TermWhitespace says that we add a whitespace character
+	// at the end of an encoding.
+	//
+	// The whitespace is important, especially if using numbers in a context
+	// where multiple items are written to a stream.
+	TermWhitespace bool
+
+	// MapKeyAsString says to encode all map keys as strings.
+	//
+	// Use this to enforce strict json output.
+	// The only caveat is that nil value is ALWAYS written as null (never as "null")
+	MapKeyAsString bool
 }
 
+// Name returns the name of the handle: json
+func (h *JsonHandle) Name() string { return "json" }
+
+func (h *JsonHandle) hasElemSeparators() bool { return true }
+
+// SetInterfaceExt sets an extension
 func (h *JsonHandle) SetInterfaceExt(rt reflect.Type, tag uint64, ext InterfaceExt) (err error) {
 	return h.SetExt(rt, tag, &setExtWrapper{i: ext})
 }
@@ -915,7 +1204,7 @@ func (h *JsonHandle) newDecDriver(d *Decoder) decDriver {
 }
 
 func (e *jsonEncDriver) reset() {
-	e.w = e.e.w
+	e.w = e.e.w // e.e.w // &e.e.encWriterSwitch
 	e.se.i = e.h.RawBytesExt
 	if e.bs != nil {
 		e.bs = e.bs[:0]
@@ -933,7 +1222,7 @@ func (e *jsonEncDriver) reset() {
 }
 
 func (d *jsonDecDriver) reset() {
-	d.r = d.d.r
+	d.r = d.d.r // &d.d.decReaderSwitch // d.d.r
 	d.se.i = d.h.RawBytesExt
 	if d.bs != nil {
 		d.bs = d.bs[:0]
@@ -942,10 +1231,25 @@ func (d *jsonDecDriver) reset() {
 	// d.n.reset()
 }
 
-var jsonEncodeTerminate = []byte{' '}
+// func jsonIsFloatBytes(bs []byte) bool {
+// 	for _, v := range bs {
+// 		// if v == '.' || v == 'e' || v == 'E' {
+// 		if jsonIsFloatSet.isset(v) {
+// 			return true
+// 		}
+// 	}
+// 	return false
+// }
 
-func (h *JsonHandle) rpcEncodeTerminate() []byte {
-	return jsonEncodeTerminate
+// func jsonIsFloatBytesB2(bs []byte) bool {
+// 	return bytes.IndexByte(bs, '.') != -1 ||
+// 		bytes.IndexByte(bs, 'E') != -1
+// }
+
+func jsonIsFloatBytesB3(bs []byte) bool {
+	return bytes.IndexByte(bs, '.') != -1 ||
+		bytes.IndexByte(bs, 'E') != -1 ||
+		bytes.IndexByte(bs, 'e') != -1
 }
 
 var _ decDriver = (*jsonDecDriver)(nil)
diff --git a/vendor/github.com/ugorji/go/codec/mammoth-test.go.tmpl b/vendor/github.com/ugorji/go/codec/mammoth-test.go.tmpl
deleted file mode 100644
index 6d716972a..000000000
--- a/vendor/github.com/ugorji/go/codec/mammoth-test.go.tmpl
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
-// Use of this source code is governed by a MIT license found in the LICENSE file.
-
-// ************************************************************
-// DO NOT EDIT. 
-// THIS FILE IS AUTO-GENERATED from mammoth-test.go.tmpl
-// ************************************************************
-
-package codec
-
-// 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.
-
-type TestMammoth struct {
-
-{{range .Values }}{{if .Primitive }}{{/*
-*/}}{{ .MethodNamePfx "F" true }} {{ .Primitive }}
-{{ .MethodNamePfx "Fptr" true }} *{{ .Primitive }}
-{{end}}{{end}}
-
-{{range .Values }}{{if not .Primitive }}{{if not .MapKey }}{{/*
-*/}}{{ .MethodNamePfx "F" false }} []{{ .Elem }}
-{{ .MethodNamePfx "Fptr" false }} *[]{{ .Elem }}
-{{end}}{{end}}{{end}}
-
-{{range .Values }}{{if not .Primitive }}{{if .MapKey }}{{/*
-*/}}{{ .MethodNamePfx "F" false }} map[{{ .MapKey }}]{{ .Elem }}
-{{ .MethodNamePfx "Fptr" false }} *map[{{ .MapKey }}]{{ .Elem }}
-{{end}}{{end}}{{end}}
-
-}
diff --git a/vendor/github.com/ugorji/go/codec/mammoth_generated_test.go b/vendor/github.com/ugorji/go/codec/mammoth_generated_test.go
index 73c2a7c15..3e15832cb 100644
--- a/vendor/github.com/ugorji/go/codec/mammoth_generated_test.go
+++ b/vendor/github.com/ugorji/go/codec/mammoth_generated_test.go
@@ -1,18 +1,21 @@
 // Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
 // Use of this source code is governed by a MIT license found in the LICENSE file.
 
-// ************************************************************
-// DO NOT EDIT.
-// THIS FILE IS AUTO-GENERATED from mammoth-test.go.tmpl
-// ************************************************************
+// Code generated from mammoth-test.go.tmpl - DO NOT EDIT.
 
 package codec
 
+import "testing"
+import "fmt"
+import "reflect"
+
 // 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{}
@@ -57,6 +60,8 @@ type TestMammoth struct {
 	FptrSliceFloat64 *[]float64
 	FSliceUint       []uint
 	FptrSliceUint    *[]uint
+	FSliceUint8      []uint8
+	FptrSliceUint8   *[]uint8
 	FSliceUint16     []uint16
 	FptrSliceUint16  *[]uint16
 	FSliceUint32     []uint32
@@ -591,3 +596,12593 @@ type TestMammoth struct {
 	FMapBoolBool          map[bool]bool
 	FptrMapBoolBool       *map[bool]bool
 }
+
+type typMbsSliceIntf []interface{}
+
+func (_ typMbsSliceIntf) MapBySlice() {}
+
+type typMbsSliceString []string
+
+func (_ typMbsSliceString) MapBySlice() {}
+
+type typMbsSliceFloat32 []float32
+
+func (_ typMbsSliceFloat32) MapBySlice() {}
+
+type typMbsSliceFloat64 []float64
+
+func (_ typMbsSliceFloat64) MapBySlice() {}
+
+type typMbsSliceUint []uint
+
+func (_ typMbsSliceUint) MapBySlice() {}
+
+type typMbsSliceUint8 []uint8
+
+func (_ typMbsSliceUint8) MapBySlice() {}
+
+type typMbsSliceUint16 []uint16
+
+func (_ typMbsSliceUint16) MapBySlice() {}
+
+type typMbsSliceUint32 []uint32
+
+func (_ typMbsSliceUint32) MapBySlice() {}
+
+type typMbsSliceUint64 []uint64
+
+func (_ typMbsSliceUint64) MapBySlice() {}
+
+type typMbsSliceUintptr []uintptr
+
+func (_ typMbsSliceUintptr) MapBySlice() {}
+
+type typMbsSliceInt []int
+
+func (_ typMbsSliceInt) MapBySlice() {}
+
+type typMbsSliceInt8 []int8
+
+func (_ typMbsSliceInt8) MapBySlice() {}
+
+type typMbsSliceInt16 []int16
+
+func (_ typMbsSliceInt16) MapBySlice() {}
+
+type typMbsSliceInt32 []int32
+
+func (_ typMbsSliceInt32) MapBySlice() {}
+
+type typMbsSliceInt64 []int64
+
+func (_ typMbsSliceInt64) MapBySlice() {}
+
+type typMbsSliceBool []bool
+
+func (_ typMbsSliceBool) MapBySlice() {}
+
+type typMapMapIntfIntf map[interface{}]interface{}
+type typMapMapIntfString map[interface{}]string
+type typMapMapIntfUint map[interface{}]uint
+type typMapMapIntfUint8 map[interface{}]uint8
+type typMapMapIntfUint16 map[interface{}]uint16
+type typMapMapIntfUint32 map[interface{}]uint32
+type typMapMapIntfUint64 map[interface{}]uint64
+type typMapMapIntfUintptr map[interface{}]uintptr
+type typMapMapIntfInt map[interface{}]int
+type typMapMapIntfInt8 map[interface{}]int8
+type typMapMapIntfInt16 map[interface{}]int16
+type typMapMapIntfInt32 map[interface{}]int32
+type typMapMapIntfInt64 map[interface{}]int64
+type typMapMapIntfFloat32 map[interface{}]float32
+type typMapMapIntfFloat64 map[interface{}]float64
+type typMapMapIntfBool map[interface{}]bool
+type typMapMapStringIntf map[string]interface{}
+type typMapMapStringString map[string]string
+type typMapMapStringUint map[string]uint
+type typMapMapStringUint8 map[string]uint8
+type typMapMapStringUint16 map[string]uint16
+type typMapMapStringUint32 map[string]uint32
+type typMapMapStringUint64 map[string]uint64
+type typMapMapStringUintptr map[string]uintptr
+type typMapMapStringInt map[string]int
+type typMapMapStringInt8 map[string]int8
+type typMapMapStringInt16 map[string]int16
+type typMapMapStringInt32 map[string]int32
+type typMapMapStringInt64 map[string]int64
+type typMapMapStringFloat32 map[string]float32
+type typMapMapStringFloat64 map[string]float64
+type typMapMapStringBool map[string]bool
+type typMapMapFloat32Intf map[float32]interface{}
+type typMapMapFloat32String map[float32]string
+type typMapMapFloat32Uint map[float32]uint
+type typMapMapFloat32Uint8 map[float32]uint8
+type typMapMapFloat32Uint16 map[float32]uint16
+type typMapMapFloat32Uint32 map[float32]uint32
+type typMapMapFloat32Uint64 map[float32]uint64
+type typMapMapFloat32Uintptr map[float32]uintptr
+type typMapMapFloat32Int map[float32]int
+type typMapMapFloat32Int8 map[float32]int8
+type typMapMapFloat32Int16 map[float32]int16
+type typMapMapFloat32Int32 map[float32]int32
+type typMapMapFloat32Int64 map[float32]int64
+type typMapMapFloat32Float32 map[float32]float32
+type typMapMapFloat32Float64 map[float32]float64
+type typMapMapFloat32Bool map[float32]bool
+type typMapMapFloat64Intf map[float64]interface{}
+type typMapMapFloat64String map[float64]string
+type typMapMapFloat64Uint map[float64]uint
+type typMapMapFloat64Uint8 map[float64]uint8
+type typMapMapFloat64Uint16 map[float64]uint16
+type typMapMapFloat64Uint32 map[float64]uint32
+type typMapMapFloat64Uint64 map[float64]uint64
+type typMapMapFloat64Uintptr map[float64]uintptr
+type typMapMapFloat64Int map[float64]int
+type typMapMapFloat64Int8 map[float64]int8
+type typMapMapFloat64Int16 map[float64]int16
+type typMapMapFloat64Int32 map[float64]int32
+type typMapMapFloat64Int64 map[float64]int64
+type typMapMapFloat64Float32 map[float64]float32
+type typMapMapFloat64Float64 map[float64]float64
+type typMapMapFloat64Bool map[float64]bool
+type typMapMapUintIntf map[uint]interface{}
+type typMapMapUintString map[uint]string
+type typMapMapUintUint map[uint]uint
+type typMapMapUintUint8 map[uint]uint8
+type typMapMapUintUint16 map[uint]uint16
+type typMapMapUintUint32 map[uint]uint32
+type typMapMapUintUint64 map[uint]uint64
+type typMapMapUintUintptr map[uint]uintptr
+type typMapMapUintInt map[uint]int
+type typMapMapUintInt8 map[uint]int8
+type typMapMapUintInt16 map[uint]int16
+type typMapMapUintInt32 map[uint]int32
+type typMapMapUintInt64 map[uint]int64
+type typMapMapUintFloat32 map[uint]float32
+type typMapMapUintFloat64 map[uint]float64
+type typMapMapUintBool map[uint]bool
+type typMapMapUint8Intf map[uint8]interface{}
+type typMapMapUint8String map[uint8]string
+type typMapMapUint8Uint map[uint8]uint
+type typMapMapUint8Uint8 map[uint8]uint8
+type typMapMapUint8Uint16 map[uint8]uint16
+type typMapMapUint8Uint32 map[uint8]uint32
+type typMapMapUint8Uint64 map[uint8]uint64
+type typMapMapUint8Uintptr map[uint8]uintptr
+type typMapMapUint8Int map[uint8]int
+type typMapMapUint8Int8 map[uint8]int8
+type typMapMapUint8Int16 map[uint8]int16
+type typMapMapUint8Int32 map[uint8]int32
+type typMapMapUint8Int64 map[uint8]int64
+type typMapMapUint8Float32 map[uint8]float32
+type typMapMapUint8Float64 map[uint8]float64
+type typMapMapUint8Bool map[uint8]bool
+type typMapMapUint16Intf map[uint16]interface{}
+type typMapMapUint16String map[uint16]string
+type typMapMapUint16Uint map[uint16]uint
+type typMapMapUint16Uint8 map[uint16]uint8
+type typMapMapUint16Uint16 map[uint16]uint16
+type typMapMapUint16Uint32 map[uint16]uint32
+type typMapMapUint16Uint64 map[uint16]uint64
+type typMapMapUint16Uintptr map[uint16]uintptr
+type typMapMapUint16Int map[uint16]int
+type typMapMapUint16Int8 map[uint16]int8
+type typMapMapUint16Int16 map[uint16]int16
+type typMapMapUint16Int32 map[uint16]int32
+type typMapMapUint16Int64 map[uint16]int64
+type typMapMapUint16Float32 map[uint16]float32
+type typMapMapUint16Float64 map[uint16]float64
+type typMapMapUint16Bool map[uint16]bool
+type typMapMapUint32Intf map[uint32]interface{}
+type typMapMapUint32String map[uint32]string
+type typMapMapUint32Uint map[uint32]uint
+type typMapMapUint32Uint8 map[uint32]uint8
+type typMapMapUint32Uint16 map[uint32]uint16
+type typMapMapUint32Uint32 map[uint32]uint32
+type typMapMapUint32Uint64 map[uint32]uint64
+type typMapMapUint32Uintptr map[uint32]uintptr
+type typMapMapUint32Int map[uint32]int
+type typMapMapUint32Int8 map[uint32]int8
+type typMapMapUint32Int16 map[uint32]int16
+type typMapMapUint32Int32 map[uint32]int32
+type typMapMapUint32Int64 map[uint32]int64
+type typMapMapUint32Float32 map[uint32]float32
+type typMapMapUint32Float64 map[uint32]float64
+type typMapMapUint32Bool map[uint32]bool
+type typMapMapUint64Intf map[uint64]interface{}
+type typMapMapUint64String map[uint64]string
+type typMapMapUint64Uint map[uint64]uint
+type typMapMapUint64Uint8 map[uint64]uint8
+type typMapMapUint64Uint16 map[uint64]uint16
+type typMapMapUint64Uint32 map[uint64]uint32
+type typMapMapUint64Uint64 map[uint64]uint64
+type typMapMapUint64Uintptr map[uint64]uintptr
+type typMapMapUint64Int map[uint64]int
+type typMapMapUint64Int8 map[uint64]int8
+type typMapMapUint64Int16 map[uint64]int16
+type typMapMapUint64Int32 map[uint64]int32
+type typMapMapUint64Int64 map[uint64]int64
+type typMapMapUint64Float32 map[uint64]float32
+type typMapMapUint64Float64 map[uint64]float64
+type typMapMapUint64Bool map[uint64]bool
+type typMapMapUintptrIntf map[uintptr]interface{}
+type typMapMapUintptrString map[uintptr]string
+type typMapMapUintptrUint map[uintptr]uint
+type typMapMapUintptrUint8 map[uintptr]uint8
+type typMapMapUintptrUint16 map[uintptr]uint16
+type typMapMapUintptrUint32 map[uintptr]uint32
+type typMapMapUintptrUint64 map[uintptr]uint64
+type typMapMapUintptrUintptr map[uintptr]uintptr
+type typMapMapUintptrInt map[uintptr]int
+type typMapMapUintptrInt8 map[uintptr]int8
+type typMapMapUintptrInt16 map[uintptr]int16
+type typMapMapUintptrInt32 map[uintptr]int32
+type typMapMapUintptrInt64 map[uintptr]int64
+type typMapMapUintptrFloat32 map[uintptr]float32
+type typMapMapUintptrFloat64 map[uintptr]float64
+type typMapMapUintptrBool map[uintptr]bool
+type typMapMapIntIntf map[int]interface{}
+type typMapMapIntString map[int]string
+type typMapMapIntUint map[int]uint
+type typMapMapIntUint8 map[int]uint8
+type typMapMapIntUint16 map[int]uint16
+type typMapMapIntUint32 map[int]uint32
+type typMapMapIntUint64 map[int]uint64
+type typMapMapIntUintptr map[int]uintptr
+type typMapMapIntInt map[int]int
+type typMapMapIntInt8 map[int]int8
+type typMapMapIntInt16 map[int]int16
+type typMapMapIntInt32 map[int]int32
+type typMapMapIntInt64 map[int]int64
+type typMapMapIntFloat32 map[int]float32
+type typMapMapIntFloat64 map[int]float64
+type typMapMapIntBool map[int]bool
+type typMapMapInt8Intf map[int8]interface{}
+type typMapMapInt8String map[int8]string
+type typMapMapInt8Uint map[int8]uint
+type typMapMapInt8Uint8 map[int8]uint8
+type typMapMapInt8Uint16 map[int8]uint16
+type typMapMapInt8Uint32 map[int8]uint32
+type typMapMapInt8Uint64 map[int8]uint64
+type typMapMapInt8Uintptr map[int8]uintptr
+type typMapMapInt8Int map[int8]int
+type typMapMapInt8Int8 map[int8]int8
+type typMapMapInt8Int16 map[int8]int16
+type typMapMapInt8Int32 map[int8]int32
+type typMapMapInt8Int64 map[int8]int64
+type typMapMapInt8Float32 map[int8]float32
+type typMapMapInt8Float64 map[int8]float64
+type typMapMapInt8Bool map[int8]bool
+type typMapMapInt16Intf map[int16]interface{}
+type typMapMapInt16String map[int16]string
+type typMapMapInt16Uint map[int16]uint
+type typMapMapInt16Uint8 map[int16]uint8
+type typMapMapInt16Uint16 map[int16]uint16
+type typMapMapInt16Uint32 map[int16]uint32
+type typMapMapInt16Uint64 map[int16]uint64
+type typMapMapInt16Uintptr map[int16]uintptr
+type typMapMapInt16Int map[int16]int
+type typMapMapInt16Int8 map[int16]int8
+type typMapMapInt16Int16 map[int16]int16
+type typMapMapInt16Int32 map[int16]int32
+type typMapMapInt16Int64 map[int16]int64
+type typMapMapInt16Float32 map[int16]float32
+type typMapMapInt16Float64 map[int16]float64
+type typMapMapInt16Bool map[int16]bool
+type typMapMapInt32Intf map[int32]interface{}
+type typMapMapInt32String map[int32]string
+type typMapMapInt32Uint map[int32]uint
+type typMapMapInt32Uint8 map[int32]uint8
+type typMapMapInt32Uint16 map[int32]uint16
+type typMapMapInt32Uint32 map[int32]uint32
+type typMapMapInt32Uint64 map[int32]uint64
+type typMapMapInt32Uintptr map[int32]uintptr
+type typMapMapInt32Int map[int32]int
+type typMapMapInt32Int8 map[int32]int8
+type typMapMapInt32Int16 map[int32]int16
+type typMapMapInt32Int32 map[int32]int32
+type typMapMapInt32Int64 map[int32]int64
+type typMapMapInt32Float32 map[int32]float32
+type typMapMapInt32Float64 map[int32]float64
+type typMapMapInt32Bool map[int32]bool
+type typMapMapInt64Intf map[int64]interface{}
+type typMapMapInt64String map[int64]string
+type typMapMapInt64Uint map[int64]uint
+type typMapMapInt64Uint8 map[int64]uint8
+type typMapMapInt64Uint16 map[int64]uint16
+type typMapMapInt64Uint32 map[int64]uint32
+type typMapMapInt64Uint64 map[int64]uint64
+type typMapMapInt64Uintptr map[int64]uintptr
+type typMapMapInt64Int map[int64]int
+type typMapMapInt64Int8 map[int64]int8
+type typMapMapInt64Int16 map[int64]int16
+type typMapMapInt64Int32 map[int64]int32
+type typMapMapInt64Int64 map[int64]int64
+type typMapMapInt64Float32 map[int64]float32
+type typMapMapInt64Float64 map[int64]float64
+type typMapMapInt64Bool map[int64]bool
+type typMapMapBoolIntf map[bool]interface{}
+type typMapMapBoolString map[bool]string
+type typMapMapBoolUint map[bool]uint
+type typMapMapBoolUint8 map[bool]uint8
+type typMapMapBoolUint16 map[bool]uint16
+type typMapMapBoolUint32 map[bool]uint32
+type typMapMapBoolUint64 map[bool]uint64
+type typMapMapBoolUintptr map[bool]uintptr
+type typMapMapBoolInt map[bool]int
+type typMapMapBoolInt8 map[bool]int8
+type typMapMapBoolInt16 map[bool]int16
+type typMapMapBoolInt32 map[bool]int32
+type typMapMapBoolInt64 map[bool]int64
+type typMapMapBoolFloat32 map[bool]float32
+type typMapMapBoolFloat64 map[bool]float64
+type typMapMapBoolBool map[bool]bool
+
+func doTestMammothSlices(t *testing.T, h Handle) {
+
+	var v1va [8]interface{}
+	for _, v := range [][]interface{}{nil, {}, {"string-is-an-interface-2", nil, nil, "string-is-an-interface"}} {
+		var v1v1, v1v2 []interface{}
+		v1v1 = v
+		bs1 := testMarshalErr(v1v1, h, t, "enc-slice-v1")
+		if v == nil {
+			v1v2 = nil
+		} else {
+			v1v2 = make([]interface{}, len(v))
+		}
+		testUnmarshalErr(v1v2, bs1, h, t, "dec-slice-v1")
+		testDeepEqualErr(v1v1, v1v2, t, "equal-slice-v1")
+		if v == nil {
+			v1v2 = nil
+		} else {
+			v1v2 = make([]interface{}, len(v))
+		}
+		testUnmarshalErr(reflect.ValueOf(v1v2), bs1, h, t, "dec-slice-v1-noaddr") // non-addressable value
+		testDeepEqualErr(v1v1, v1v2, t, "equal-slice-v1-noaddr")
+		// ...
+		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")
+		v1va = [8]interface{}{} // clear the array
+		v1v2 = v1va[:1:1]
+		testUnmarshalErr(&v1v2, bs1, h, t, "dec-slice-v1-p-1")
+		testDeepEqualErr(v1v1, v1v2, t, "equal-slice-v1-p-1")
+		v1va = [8]interface{}{} // clear the array
+		v1v2 = v1va[:len(v1v1):len(v1v1)]
+		testUnmarshalErr(&v1v2, bs1, h, t, "dec-slice-v1-p-len")
+		testDeepEqualErr(v1v1, v1v2, t, "equal-slice-v1-p-len")
+		v1va = [8]interface{}{} // clear the array
+		v1v2 = v1va[:]
+		testUnmarshalErr(&v1v2, bs1, h, t, "dec-slice-v1-p-cap")
+		testDeepEqualErr(v1v1, v1v2, t, "equal-slice-v1-p-cap")
+		if len(v1v1) > 1 {
+			v1va = [8]interface{}{} // clear the array
+			testUnmarshalErr((&v1va)[:len(v1v1)], bs1, h, t, "dec-slice-v1-p-len-noaddr")
+			testDeepEqualErr(v1v1, v1va[:len(v1v1)], t, "equal-slice-v1-p-len-noaddr")
+			v1va = [8]interface{}{} // clear the array
+			testUnmarshalErr((&v1va)[:], bs1, h, t, "dec-slice-v1-p-cap-noaddr")
+			testDeepEqualErr(v1v1, v1va[:len(v1v1)], t, "equal-slice-v1-p-cap-noaddr")
+		}
+		// ...
+		var v1v3, v1v4 typMbsSliceIntf
+		v1v2 = nil
+		if v != nil {
+			v1v2 = make([]interface{}, len(v))
+		}
+		v1v3 = typMbsSliceIntf(v1v1)
+		v1v4 = typMbsSliceIntf(v1v2)
+		bs1 = testMarshalErr(v1v3, h, t, "enc-slice-v1-custom")
+		testUnmarshalErr(v1v4, bs1, h, t, "dec-slice-v1-custom")
+		testDeepEqualErr(v1v3, v1v4, t, "equal-slice-v1-custom")
+		bs1 = testMarshalErr(&v1v3, h, t, "enc-slice-v1-custom-p")
+		v1v2 = nil
+		v1v4 = typMbsSliceIntf(v1v2)
+		testUnmarshalErr(&v1v4, bs1, h, t, "dec-slice-v1-custom-p")
+		testDeepEqualErr(v1v3, v1v4, t, "equal-slice-v1-custom-p")
+	}
+
+	var v19va [8]string
+	for _, v := range [][]string{nil, {}, {"some-string-2", "", "", "some-string"}} {
+		var v19v1, v19v2 []string
+		v19v1 = v
+		bs19 := testMarshalErr(v19v1, h, t, "enc-slice-v19")
+		if v == nil {
+			v19v2 = nil
+		} else {
+			v19v2 = make([]string, len(v))
+		}
+		testUnmarshalErr(v19v2, bs19, h, t, "dec-slice-v19")
+		testDeepEqualErr(v19v1, v19v2, t, "equal-slice-v19")
+		if v == nil {
+			v19v2 = nil
+		} else {
+			v19v2 = make([]string, len(v))
+		}
+		testUnmarshalErr(reflect.ValueOf(v19v2), bs19, h, t, "dec-slice-v19-noaddr") // non-addressable value
+		testDeepEqualErr(v19v1, v19v2, t, "equal-slice-v19-noaddr")
+		// ...
+		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")
+		v19va = [8]string{} // clear the array
+		v19v2 = v19va[:1:1]
+		testUnmarshalErr(&v19v2, bs19, h, t, "dec-slice-v19-p-1")
+		testDeepEqualErr(v19v1, v19v2, t, "equal-slice-v19-p-1")
+		v19va = [8]string{} // clear the array
+		v19v2 = v19va[:len(v19v1):len(v19v1)]
+		testUnmarshalErr(&v19v2, bs19, h, t, "dec-slice-v19-p-len")
+		testDeepEqualErr(v19v1, v19v2, t, "equal-slice-v19-p-len")
+		v19va = [8]string{} // clear the array
+		v19v2 = v19va[:]
+		testUnmarshalErr(&v19v2, bs19, h, t, "dec-slice-v19-p-cap")
+		testDeepEqualErr(v19v1, v19v2, t, "equal-slice-v19-p-cap")
+		if len(v19v1) > 1 {
+			v19va = [8]string{} // clear the array
+			testUnmarshalErr((&v19va)[:len(v19v1)], bs19, h, t, "dec-slice-v19-p-len-noaddr")
+			testDeepEqualErr(v19v1, v19va[:len(v19v1)], t, "equal-slice-v19-p-len-noaddr")
+			v19va = [8]string{} // clear the array
+			testUnmarshalErr((&v19va)[:], bs19, h, t, "dec-slice-v19-p-cap-noaddr")
+			testDeepEqualErr(v19v1, v19va[:len(v19v1)], t, "equal-slice-v19-p-cap-noaddr")
+		}
+		// ...
+		var v19v3, v19v4 typMbsSliceString
+		v19v2 = nil
+		if v != nil {
+			v19v2 = make([]string, len(v))
+		}
+		v19v3 = typMbsSliceString(v19v1)
+		v19v4 = typMbsSliceString(v19v2)
+		bs19 = testMarshalErr(v19v3, h, t, "enc-slice-v19-custom")
+		testUnmarshalErr(v19v4, bs19, h, t, "dec-slice-v19-custom")
+		testDeepEqualErr(v19v3, v19v4, t, "equal-slice-v19-custom")
+		bs19 = testMarshalErr(&v19v3, h, t, "enc-slice-v19-custom-p")
+		v19v2 = nil
+		v19v4 = typMbsSliceString(v19v2)
+		testUnmarshalErr(&v19v4, bs19, h, t, "dec-slice-v19-custom-p")
+		testDeepEqualErr(v19v3, v19v4, t, "equal-slice-v19-custom-p")
+	}
+
+	var v37va [8]float32
+	for _, v := range [][]float32{nil, {}, {22.2, 0, 0, 11.1}} {
+		var v37v1, v37v2 []float32
+		v37v1 = v
+		bs37 := testMarshalErr(v37v1, h, t, "enc-slice-v37")
+		if v == nil {
+			v37v2 = nil
+		} else {
+			v37v2 = make([]float32, len(v))
+		}
+		testUnmarshalErr(v37v2, bs37, h, t, "dec-slice-v37")
+		testDeepEqualErr(v37v1, v37v2, t, "equal-slice-v37")
+		if v == nil {
+			v37v2 = nil
+		} else {
+			v37v2 = make([]float32, len(v))
+		}
+		testUnmarshalErr(reflect.ValueOf(v37v2), bs37, h, t, "dec-slice-v37-noaddr") // non-addressable value
+		testDeepEqualErr(v37v1, v37v2, t, "equal-slice-v37-noaddr")
+		// ...
+		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")
+		v37va = [8]float32{} // clear the array
+		v37v2 = v37va[:1:1]
+		testUnmarshalErr(&v37v2, bs37, h, t, "dec-slice-v37-p-1")
+		testDeepEqualErr(v37v1, v37v2, t, "equal-slice-v37-p-1")
+		v37va = [8]float32{} // clear the array
+		v37v2 = v37va[:len(v37v1):len(v37v1)]
+		testUnmarshalErr(&v37v2, bs37, h, t, "dec-slice-v37-p-len")
+		testDeepEqualErr(v37v1, v37v2, t, "equal-slice-v37-p-len")
+		v37va = [8]float32{} // clear the array
+		v37v2 = v37va[:]
+		testUnmarshalErr(&v37v2, bs37, h, t, "dec-slice-v37-p-cap")
+		testDeepEqualErr(v37v1, v37v2, t, "equal-slice-v37-p-cap")
+		if len(v37v1) > 1 {
+			v37va = [8]float32{} // clear the array
+			testUnmarshalErr((&v37va)[:len(v37v1)], bs37, h, t, "dec-slice-v37-p-len-noaddr")
+			testDeepEqualErr(v37v1, v37va[:len(v37v1)], t, "equal-slice-v37-p-len-noaddr")
+			v37va = [8]float32{} // clear the array
+			testUnmarshalErr((&v37va)[:], bs37, h, t, "dec-slice-v37-p-cap-noaddr")
+			testDeepEqualErr(v37v1, v37va[:len(v37v1)], t, "equal-slice-v37-p-cap-noaddr")
+		}
+		// ...
+		var v37v3, v37v4 typMbsSliceFloat32
+		v37v2 = nil
+		if v != nil {
+			v37v2 = make([]float32, len(v))
+		}
+		v37v3 = typMbsSliceFloat32(v37v1)
+		v37v4 = typMbsSliceFloat32(v37v2)
+		bs37 = testMarshalErr(v37v3, h, t, "enc-slice-v37-custom")
+		testUnmarshalErr(v37v4, bs37, h, t, "dec-slice-v37-custom")
+		testDeepEqualErr(v37v3, v37v4, t, "equal-slice-v37-custom")
+		bs37 = testMarshalErr(&v37v3, h, t, "enc-slice-v37-custom-p")
+		v37v2 = nil
+		v37v4 = typMbsSliceFloat32(v37v2)
+		testUnmarshalErr(&v37v4, bs37, h, t, "dec-slice-v37-custom-p")
+		testDeepEqualErr(v37v3, v37v4, t, "equal-slice-v37-custom-p")
+	}
+
+	var v55va [8]float64
+	for _, v := range [][]float64{nil, {}, {22.2, 0, 0, 11.1}} {
+		var v55v1, v55v2 []float64
+		v55v1 = v
+		bs55 := testMarshalErr(v55v1, h, t, "enc-slice-v55")
+		if v == nil {
+			v55v2 = nil
+		} else {
+			v55v2 = make([]float64, len(v))
+		}
+		testUnmarshalErr(v55v2, bs55, h, t, "dec-slice-v55")
+		testDeepEqualErr(v55v1, v55v2, t, "equal-slice-v55")
+		if v == nil {
+			v55v2 = nil
+		} else {
+			v55v2 = make([]float64, len(v))
+		}
+		testUnmarshalErr(reflect.ValueOf(v55v2), bs55, h, t, "dec-slice-v55-noaddr") // non-addressable value
+		testDeepEqualErr(v55v1, v55v2, t, "equal-slice-v55-noaddr")
+		// ...
+		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")
+		v55va = [8]float64{} // clear the array
+		v55v2 = v55va[:1:1]
+		testUnmarshalErr(&v55v2, bs55, h, t, "dec-slice-v55-p-1")
+		testDeepEqualErr(v55v1, v55v2, t, "equal-slice-v55-p-1")
+		v55va = [8]float64{} // clear the array
+		v55v2 = v55va[:len(v55v1):len(v55v1)]
+		testUnmarshalErr(&v55v2, bs55, h, t, "dec-slice-v55-p-len")
+		testDeepEqualErr(v55v1, v55v2, t, "equal-slice-v55-p-len")
+		v55va = [8]float64{} // clear the array
+		v55v2 = v55va[:]
+		testUnmarshalErr(&v55v2, bs55, h, t, "dec-slice-v55-p-cap")
+		testDeepEqualErr(v55v1, v55v2, t, "equal-slice-v55-p-cap")
+		if len(v55v1) > 1 {
+			v55va = [8]float64{} // clear the array
+			testUnmarshalErr((&v55va)[:len(v55v1)], bs55, h, t, "dec-slice-v55-p-len-noaddr")
+			testDeepEqualErr(v55v1, v55va[:len(v55v1)], t, "equal-slice-v55-p-len-noaddr")
+			v55va = [8]float64{} // clear the array
+			testUnmarshalErr((&v55va)[:], bs55, h, t, "dec-slice-v55-p-cap-noaddr")
+			testDeepEqualErr(v55v1, v55va[:len(v55v1)], t, "equal-slice-v55-p-cap-noaddr")
+		}
+		// ...
+		var v55v3, v55v4 typMbsSliceFloat64
+		v55v2 = nil
+		if v != nil {
+			v55v2 = make([]float64, len(v))
+		}
+		v55v3 = typMbsSliceFloat64(v55v1)
+		v55v4 = typMbsSliceFloat64(v55v2)
+		bs55 = testMarshalErr(v55v3, h, t, "enc-slice-v55-custom")
+		testUnmarshalErr(v55v4, bs55, h, t, "dec-slice-v55-custom")
+		testDeepEqualErr(v55v3, v55v4, t, "equal-slice-v55-custom")
+		bs55 = testMarshalErr(&v55v3, h, t, "enc-slice-v55-custom-p")
+		v55v2 = nil
+		v55v4 = typMbsSliceFloat64(v55v2)
+		testUnmarshalErr(&v55v4, bs55, h, t, "dec-slice-v55-custom-p")
+		testDeepEqualErr(v55v3, v55v4, t, "equal-slice-v55-custom-p")
+	}
+
+	var v73va [8]uint
+	for _, v := range [][]uint{nil, {}, {44, 0, 0, 33}} {
+		var v73v1, v73v2 []uint
+		v73v1 = v
+		bs73 := testMarshalErr(v73v1, h, t, "enc-slice-v73")
+		if v == nil {
+			v73v2 = nil
+		} else {
+			v73v2 = make([]uint, len(v))
+		}
+		testUnmarshalErr(v73v2, bs73, h, t, "dec-slice-v73")
+		testDeepEqualErr(v73v1, v73v2, t, "equal-slice-v73")
+		if v == nil {
+			v73v2 = nil
+		} else {
+			v73v2 = make([]uint, len(v))
+		}
+		testUnmarshalErr(reflect.ValueOf(v73v2), bs73, h, t, "dec-slice-v73-noaddr") // non-addressable value
+		testDeepEqualErr(v73v1, v73v2, t, "equal-slice-v73-noaddr")
+		// ...
+		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")
+		v73va = [8]uint{} // clear the array
+		v73v2 = v73va[:1:1]
+		testUnmarshalErr(&v73v2, bs73, h, t, "dec-slice-v73-p-1")
+		testDeepEqualErr(v73v1, v73v2, t, "equal-slice-v73-p-1")
+		v73va = [8]uint{} // clear the array
+		v73v2 = v73va[:len(v73v1):len(v73v1)]
+		testUnmarshalErr(&v73v2, bs73, h, t, "dec-slice-v73-p-len")
+		testDeepEqualErr(v73v1, v73v2, t, "equal-slice-v73-p-len")
+		v73va = [8]uint{} // clear the array
+		v73v2 = v73va[:]
+		testUnmarshalErr(&v73v2, bs73, h, t, "dec-slice-v73-p-cap")
+		testDeepEqualErr(v73v1, v73v2, t, "equal-slice-v73-p-cap")
+		if len(v73v1) > 1 {
+			v73va = [8]uint{} // clear the array
+			testUnmarshalErr((&v73va)[:len(v73v1)], bs73, h, t, "dec-slice-v73-p-len-noaddr")
+			testDeepEqualErr(v73v1, v73va[:len(v73v1)], t, "equal-slice-v73-p-len-noaddr")
+			v73va = [8]uint{} // clear the array
+			testUnmarshalErr((&v73va)[:], bs73, h, t, "dec-slice-v73-p-cap-noaddr")
+			testDeepEqualErr(v73v1, v73va[:len(v73v1)], t, "equal-slice-v73-p-cap-noaddr")
+		}
+		// ...
+		var v73v3, v73v4 typMbsSliceUint
+		v73v2 = nil
+		if v != nil {
+			v73v2 = make([]uint, len(v))
+		}
+		v73v3 = typMbsSliceUint(v73v1)
+		v73v4 = typMbsSliceUint(v73v2)
+		bs73 = testMarshalErr(v73v3, h, t, "enc-slice-v73-custom")
+		testUnmarshalErr(v73v4, bs73, h, t, "dec-slice-v73-custom")
+		testDeepEqualErr(v73v3, v73v4, t, "equal-slice-v73-custom")
+		bs73 = testMarshalErr(&v73v3, h, t, "enc-slice-v73-custom-p")
+		v73v2 = nil
+		v73v4 = typMbsSliceUint(v73v2)
+		testUnmarshalErr(&v73v4, bs73, h, t, "dec-slice-v73-custom-p")
+		testDeepEqualErr(v73v3, v73v4, t, "equal-slice-v73-custom-p")
+	}
+
+	var v91va [8]uint8
+	for _, v := range [][]uint8{nil, {}, {44, 0, 0, 33}} {
+		var v91v1, v91v2 []uint8
+		v91v1 = v
+		bs91 := testMarshalErr(v91v1, h, t, "enc-slice-v91")
+		if v == nil {
+			v91v2 = nil
+		} else {
+			v91v2 = make([]uint8, len(v))
+		}
+		testUnmarshalErr(v91v2, bs91, h, t, "dec-slice-v91")
+		testDeepEqualErr(v91v1, v91v2, t, "equal-slice-v91")
+		if v == nil {
+			v91v2 = nil
+		} else {
+			v91v2 = make([]uint8, len(v))
+		}
+		testUnmarshalErr(reflect.ValueOf(v91v2), bs91, h, t, "dec-slice-v91-noaddr") // non-addressable value
+		testDeepEqualErr(v91v1, v91v2, t, "equal-slice-v91-noaddr")
+		// ...
+		bs91 = testMarshalErr(&v91v1, h, t, "enc-slice-v91-p")
+		v91v2 = nil
+		testUnmarshalErr(&v91v2, bs91, h, t, "dec-slice-v91-p")
+		testDeepEqualErr(v91v1, v91v2, t, "equal-slice-v91-p")
+		v91va = [8]uint8{} // clear the array
+		v91v2 = v91va[:1:1]
+		testUnmarshalErr(&v91v2, bs91, h, t, "dec-slice-v91-p-1")
+		testDeepEqualErr(v91v1, v91v2, t, "equal-slice-v91-p-1")
+		v91va = [8]uint8{} // clear the array
+		v91v2 = v91va[:len(v91v1):len(v91v1)]
+		testUnmarshalErr(&v91v2, bs91, h, t, "dec-slice-v91-p-len")
+		testDeepEqualErr(v91v1, v91v2, t, "equal-slice-v91-p-len")
+		v91va = [8]uint8{} // clear the array
+		v91v2 = v91va[:]
+		testUnmarshalErr(&v91v2, bs91, h, t, "dec-slice-v91-p-cap")
+		testDeepEqualErr(v91v1, v91v2, t, "equal-slice-v91-p-cap")
+		if len(v91v1) > 1 {
+			v91va = [8]uint8{} // clear the array
+			testUnmarshalErr((&v91va)[:len(v91v1)], bs91, h, t, "dec-slice-v91-p-len-noaddr")
+			testDeepEqualErr(v91v1, v91va[:len(v91v1)], t, "equal-slice-v91-p-len-noaddr")
+			v91va = [8]uint8{} // clear the array
+			testUnmarshalErr((&v91va)[:], bs91, h, t, "dec-slice-v91-p-cap-noaddr")
+			testDeepEqualErr(v91v1, v91va[:len(v91v1)], t, "equal-slice-v91-p-cap-noaddr")
+		}
+		// ...
+		var v91v3, v91v4 typMbsSliceUint8
+		v91v2 = nil
+		if v != nil {
+			v91v2 = make([]uint8, len(v))
+		}
+		v91v3 = typMbsSliceUint8(v91v1)
+		v91v4 = typMbsSliceUint8(v91v2)
+		bs91 = testMarshalErr(v91v3, h, t, "enc-slice-v91-custom")
+		testUnmarshalErr(v91v4, bs91, h, t, "dec-slice-v91-custom")
+		testDeepEqualErr(v91v3, v91v4, t, "equal-slice-v91-custom")
+		bs91 = testMarshalErr(&v91v3, h, t, "enc-slice-v91-custom-p")
+		v91v2 = nil
+		v91v4 = typMbsSliceUint8(v91v2)
+		testUnmarshalErr(&v91v4, bs91, h, t, "dec-slice-v91-custom-p")
+		testDeepEqualErr(v91v3, v91v4, t, "equal-slice-v91-custom-p")
+	}
+
+	var v109va [8]uint16
+	for _, v := range [][]uint16{nil, {}, {44, 0, 0, 33}} {
+		var v109v1, v109v2 []uint16
+		v109v1 = v
+		bs109 := testMarshalErr(v109v1, h, t, "enc-slice-v109")
+		if v == nil {
+			v109v2 = nil
+		} else {
+			v109v2 = make([]uint16, len(v))
+		}
+		testUnmarshalErr(v109v2, bs109, h, t, "dec-slice-v109")
+		testDeepEqualErr(v109v1, v109v2, t, "equal-slice-v109")
+		if v == nil {
+			v109v2 = nil
+		} else {
+			v109v2 = make([]uint16, len(v))
+		}
+		testUnmarshalErr(reflect.ValueOf(v109v2), bs109, h, t, "dec-slice-v109-noaddr") // non-addressable value
+		testDeepEqualErr(v109v1, v109v2, t, "equal-slice-v109-noaddr")
+		// ...
+		bs109 = testMarshalErr(&v109v1, h, t, "enc-slice-v109-p")
+		v109v2 = nil
+		testUnmarshalErr(&v109v2, bs109, h, t, "dec-slice-v109-p")
+		testDeepEqualErr(v109v1, v109v2, t, "equal-slice-v109-p")
+		v109va = [8]uint16{} // clear the array
+		v109v2 = v109va[:1:1]
+		testUnmarshalErr(&v109v2, bs109, h, t, "dec-slice-v109-p-1")
+		testDeepEqualErr(v109v1, v109v2, t, "equal-slice-v109-p-1")
+		v109va = [8]uint16{} // clear the array
+		v109v2 = v109va[:len(v109v1):len(v109v1)]
+		testUnmarshalErr(&v109v2, bs109, h, t, "dec-slice-v109-p-len")
+		testDeepEqualErr(v109v1, v109v2, t, "equal-slice-v109-p-len")
+		v109va = [8]uint16{} // clear the array
+		v109v2 = v109va[:]
+		testUnmarshalErr(&v109v2, bs109, h, t, "dec-slice-v109-p-cap")
+		testDeepEqualErr(v109v1, v109v2, t, "equal-slice-v109-p-cap")
+		if len(v109v1) > 1 {
+			v109va = [8]uint16{} // clear the array
+			testUnmarshalErr((&v109va)[:len(v109v1)], bs109, h, t, "dec-slice-v109-p-len-noaddr")
+			testDeepEqualErr(v109v1, v109va[:len(v109v1)], t, "equal-slice-v109-p-len-noaddr")
+			v109va = [8]uint16{} // clear the array
+			testUnmarshalErr((&v109va)[:], bs109, h, t, "dec-slice-v109-p-cap-noaddr")
+			testDeepEqualErr(v109v1, v109va[:len(v109v1)], t, "equal-slice-v109-p-cap-noaddr")
+		}
+		// ...
+		var v109v3, v109v4 typMbsSliceUint16
+		v109v2 = nil
+		if v != nil {
+			v109v2 = make([]uint16, len(v))
+		}
+		v109v3 = typMbsSliceUint16(v109v1)
+		v109v4 = typMbsSliceUint16(v109v2)
+		bs109 = testMarshalErr(v109v3, h, t, "enc-slice-v109-custom")
+		testUnmarshalErr(v109v4, bs109, h, t, "dec-slice-v109-custom")
+		testDeepEqualErr(v109v3, v109v4, t, "equal-slice-v109-custom")
+		bs109 = testMarshalErr(&v109v3, h, t, "enc-slice-v109-custom-p")
+		v109v2 = nil
+		v109v4 = typMbsSliceUint16(v109v2)
+		testUnmarshalErr(&v109v4, bs109, h, t, "dec-slice-v109-custom-p")
+		testDeepEqualErr(v109v3, v109v4, t, "equal-slice-v109-custom-p")
+	}
+
+	var v127va [8]uint32
+	for _, v := range [][]uint32{nil, {}, {44, 0, 0, 33}} {
+		var v127v1, v127v2 []uint32
+		v127v1 = v
+		bs127 := testMarshalErr(v127v1, h, t, "enc-slice-v127")
+		if v == nil {
+			v127v2 = nil
+		} else {
+			v127v2 = make([]uint32, len(v))
+		}
+		testUnmarshalErr(v127v2, bs127, h, t, "dec-slice-v127")
+		testDeepEqualErr(v127v1, v127v2, t, "equal-slice-v127")
+		if v == nil {
+			v127v2 = nil
+		} else {
+			v127v2 = make([]uint32, len(v))
+		}
+		testUnmarshalErr(reflect.ValueOf(v127v2), bs127, h, t, "dec-slice-v127-noaddr") // non-addressable value
+		testDeepEqualErr(v127v1, v127v2, t, "equal-slice-v127-noaddr")
+		// ...
+		bs127 = testMarshalErr(&v127v1, h, t, "enc-slice-v127-p")
+		v127v2 = nil
+		testUnmarshalErr(&v127v2, bs127, h, t, "dec-slice-v127-p")
+		testDeepEqualErr(v127v1, v127v2, t, "equal-slice-v127-p")
+		v127va = [8]uint32{} // clear the array
+		v127v2 = v127va[:1:1]
+		testUnmarshalErr(&v127v2, bs127, h, t, "dec-slice-v127-p-1")
+		testDeepEqualErr(v127v1, v127v2, t, "equal-slice-v127-p-1")
+		v127va = [8]uint32{} // clear the array
+		v127v2 = v127va[:len(v127v1):len(v127v1)]
+		testUnmarshalErr(&v127v2, bs127, h, t, "dec-slice-v127-p-len")
+		testDeepEqualErr(v127v1, v127v2, t, "equal-slice-v127-p-len")
+		v127va = [8]uint32{} // clear the array
+		v127v2 = v127va[:]
+		testUnmarshalErr(&v127v2, bs127, h, t, "dec-slice-v127-p-cap")
+		testDeepEqualErr(v127v1, v127v2, t, "equal-slice-v127-p-cap")
+		if len(v127v1) > 1 {
+			v127va = [8]uint32{} // clear the array
+			testUnmarshalErr((&v127va)[:len(v127v1)], bs127, h, t, "dec-slice-v127-p-len-noaddr")
+			testDeepEqualErr(v127v1, v127va[:len(v127v1)], t, "equal-slice-v127-p-len-noaddr")
+			v127va = [8]uint32{} // clear the array
+			testUnmarshalErr((&v127va)[:], bs127, h, t, "dec-slice-v127-p-cap-noaddr")
+			testDeepEqualErr(v127v1, v127va[:len(v127v1)], t, "equal-slice-v127-p-cap-noaddr")
+		}
+		// ...
+		var v127v3, v127v4 typMbsSliceUint32
+		v127v2 = nil
+		if v != nil {
+			v127v2 = make([]uint32, len(v))
+		}
+		v127v3 = typMbsSliceUint32(v127v1)
+		v127v4 = typMbsSliceUint32(v127v2)
+		bs127 = testMarshalErr(v127v3, h, t, "enc-slice-v127-custom")
+		testUnmarshalErr(v127v4, bs127, h, t, "dec-slice-v127-custom")
+		testDeepEqualErr(v127v3, v127v4, t, "equal-slice-v127-custom")
+		bs127 = testMarshalErr(&v127v3, h, t, "enc-slice-v127-custom-p")
+		v127v2 = nil
+		v127v4 = typMbsSliceUint32(v127v2)
+		testUnmarshalErr(&v127v4, bs127, h, t, "dec-slice-v127-custom-p")
+		testDeepEqualErr(v127v3, v127v4, t, "equal-slice-v127-custom-p")
+	}
+
+	var v145va [8]uint64
+	for _, v := range [][]uint64{nil, {}, {44, 0, 0, 33}} {
+		var v145v1, v145v2 []uint64
+		v145v1 = v
+		bs145 := testMarshalErr(v145v1, h, t, "enc-slice-v145")
+		if v == nil {
+			v145v2 = nil
+		} else {
+			v145v2 = make([]uint64, len(v))
+		}
+		testUnmarshalErr(v145v2, bs145, h, t, "dec-slice-v145")
+		testDeepEqualErr(v145v1, v145v2, t, "equal-slice-v145")
+		if v == nil {
+			v145v2 = nil
+		} else {
+			v145v2 = make([]uint64, len(v))
+		}
+		testUnmarshalErr(reflect.ValueOf(v145v2), bs145, h, t, "dec-slice-v145-noaddr") // non-addressable value
+		testDeepEqualErr(v145v1, v145v2, t, "equal-slice-v145-noaddr")
+		// ...
+		bs145 = testMarshalErr(&v145v1, h, t, "enc-slice-v145-p")
+		v145v2 = nil
+		testUnmarshalErr(&v145v2, bs145, h, t, "dec-slice-v145-p")
+		testDeepEqualErr(v145v1, v145v2, t, "equal-slice-v145-p")
+		v145va = [8]uint64{} // clear the array
+		v145v2 = v145va[:1:1]
+		testUnmarshalErr(&v145v2, bs145, h, t, "dec-slice-v145-p-1")
+		testDeepEqualErr(v145v1, v145v2, t, "equal-slice-v145-p-1")
+		v145va = [8]uint64{} // clear the array
+		v145v2 = v145va[:len(v145v1):len(v145v1)]
+		testUnmarshalErr(&v145v2, bs145, h, t, "dec-slice-v145-p-len")
+		testDeepEqualErr(v145v1, v145v2, t, "equal-slice-v145-p-len")
+		v145va = [8]uint64{} // clear the array
+		v145v2 = v145va[:]
+		testUnmarshalErr(&v145v2, bs145, h, t, "dec-slice-v145-p-cap")
+		testDeepEqualErr(v145v1, v145v2, t, "equal-slice-v145-p-cap")
+		if len(v145v1) > 1 {
+			v145va = [8]uint64{} // clear the array
+			testUnmarshalErr((&v145va)[:len(v145v1)], bs145, h, t, "dec-slice-v145-p-len-noaddr")
+			testDeepEqualErr(v145v1, v145va[:len(v145v1)], t, "equal-slice-v145-p-len-noaddr")
+			v145va = [8]uint64{} // clear the array
+			testUnmarshalErr((&v145va)[:], bs145, h, t, "dec-slice-v145-p-cap-noaddr")
+			testDeepEqualErr(v145v1, v145va[:len(v145v1)], t, "equal-slice-v145-p-cap-noaddr")
+		}
+		// ...
+		var v145v3, v145v4 typMbsSliceUint64
+		v145v2 = nil
+		if v != nil {
+			v145v2 = make([]uint64, len(v))
+		}
+		v145v3 = typMbsSliceUint64(v145v1)
+		v145v4 = typMbsSliceUint64(v145v2)
+		bs145 = testMarshalErr(v145v3, h, t, "enc-slice-v145-custom")
+		testUnmarshalErr(v145v4, bs145, h, t, "dec-slice-v145-custom")
+		testDeepEqualErr(v145v3, v145v4, t, "equal-slice-v145-custom")
+		bs145 = testMarshalErr(&v145v3, h, t, "enc-slice-v145-custom-p")
+		v145v2 = nil
+		v145v4 = typMbsSliceUint64(v145v2)
+		testUnmarshalErr(&v145v4, bs145, h, t, "dec-slice-v145-custom-p")
+		testDeepEqualErr(v145v3, v145v4, t, "equal-slice-v145-custom-p")
+	}
+
+	var v163va [8]uintptr
+	for _, v := range [][]uintptr{nil, {}, {44, 0, 0, 33}} {
+		var v163v1, v163v2 []uintptr
+		v163v1 = v
+		bs163 := testMarshalErr(v163v1, h, t, "enc-slice-v163")
+		if v == nil {
+			v163v2 = nil
+		} else {
+			v163v2 = make([]uintptr, len(v))
+		}
+		testUnmarshalErr(v163v2, bs163, h, t, "dec-slice-v163")
+		testDeepEqualErr(v163v1, v163v2, t, "equal-slice-v163")
+		if v == nil {
+			v163v2 = nil
+		} else {
+			v163v2 = make([]uintptr, len(v))
+		}
+		testUnmarshalErr(reflect.ValueOf(v163v2), bs163, h, t, "dec-slice-v163-noaddr") // non-addressable value
+		testDeepEqualErr(v163v1, v163v2, t, "equal-slice-v163-noaddr")
+		// ...
+		bs163 = testMarshalErr(&v163v1, h, t, "enc-slice-v163-p")
+		v163v2 = nil
+		testUnmarshalErr(&v163v2, bs163, h, t, "dec-slice-v163-p")
+		testDeepEqualErr(v163v1, v163v2, t, "equal-slice-v163-p")
+		v163va = [8]uintptr{} // clear the array
+		v163v2 = v163va[:1:1]
+		testUnmarshalErr(&v163v2, bs163, h, t, "dec-slice-v163-p-1")
+		testDeepEqualErr(v163v1, v163v2, t, "equal-slice-v163-p-1")
+		v163va = [8]uintptr{} // clear the array
+		v163v2 = v163va[:len(v163v1):len(v163v1)]
+		testUnmarshalErr(&v163v2, bs163, h, t, "dec-slice-v163-p-len")
+		testDeepEqualErr(v163v1, v163v2, t, "equal-slice-v163-p-len")
+		v163va = [8]uintptr{} // clear the array
+		v163v2 = v163va[:]
+		testUnmarshalErr(&v163v2, bs163, h, t, "dec-slice-v163-p-cap")
+		testDeepEqualErr(v163v1, v163v2, t, "equal-slice-v163-p-cap")
+		if len(v163v1) > 1 {
+			v163va = [8]uintptr{} // clear the array
+			testUnmarshalErr((&v163va)[:len(v163v1)], bs163, h, t, "dec-slice-v163-p-len-noaddr")
+			testDeepEqualErr(v163v1, v163va[:len(v163v1)], t, "equal-slice-v163-p-len-noaddr")
+			v163va = [8]uintptr{} // clear the array
+			testUnmarshalErr((&v163va)[:], bs163, h, t, "dec-slice-v163-p-cap-noaddr")
+			testDeepEqualErr(v163v1, v163va[:len(v163v1)], t, "equal-slice-v163-p-cap-noaddr")
+		}
+		// ...
+		var v163v3, v163v4 typMbsSliceUintptr
+		v163v2 = nil
+		if v != nil {
+			v163v2 = make([]uintptr, len(v))
+		}
+		v163v3 = typMbsSliceUintptr(v163v1)
+		v163v4 = typMbsSliceUintptr(v163v2)
+		bs163 = testMarshalErr(v163v3, h, t, "enc-slice-v163-custom")
+		testUnmarshalErr(v163v4, bs163, h, t, "dec-slice-v163-custom")
+		testDeepEqualErr(v163v3, v163v4, t, "equal-slice-v163-custom")
+		bs163 = testMarshalErr(&v163v3, h, t, "enc-slice-v163-custom-p")
+		v163v2 = nil
+		v163v4 = typMbsSliceUintptr(v163v2)
+		testUnmarshalErr(&v163v4, bs163, h, t, "dec-slice-v163-custom-p")
+		testDeepEqualErr(v163v3, v163v4, t, "equal-slice-v163-custom-p")
+	}
+
+	var v181va [8]int
+	for _, v := range [][]int{nil, {}, {44, 0, 0, 33}} {
+		var v181v1, v181v2 []int
+		v181v1 = v
+		bs181 := testMarshalErr(v181v1, h, t, "enc-slice-v181")
+		if v == nil {
+			v181v2 = nil
+		} else {
+			v181v2 = make([]int, len(v))
+		}
+		testUnmarshalErr(v181v2, bs181, h, t, "dec-slice-v181")
+		testDeepEqualErr(v181v1, v181v2, t, "equal-slice-v181")
+		if v == nil {
+			v181v2 = nil
+		} else {
+			v181v2 = make([]int, len(v))
+		}
+		testUnmarshalErr(reflect.ValueOf(v181v2), bs181, h, t, "dec-slice-v181-noaddr") // non-addressable value
+		testDeepEqualErr(v181v1, v181v2, t, "equal-slice-v181-noaddr")
+		// ...
+		bs181 = testMarshalErr(&v181v1, h, t, "enc-slice-v181-p")
+		v181v2 = nil
+		testUnmarshalErr(&v181v2, bs181, h, t, "dec-slice-v181-p")
+		testDeepEqualErr(v181v1, v181v2, t, "equal-slice-v181-p")
+		v181va = [8]int{} // clear the array
+		v181v2 = v181va[:1:1]
+		testUnmarshalErr(&v181v2, bs181, h, t, "dec-slice-v181-p-1")
+		testDeepEqualErr(v181v1, v181v2, t, "equal-slice-v181-p-1")
+		v181va = [8]int{} // clear the array
+		v181v2 = v181va[:len(v181v1):len(v181v1)]
+		testUnmarshalErr(&v181v2, bs181, h, t, "dec-slice-v181-p-len")
+		testDeepEqualErr(v181v1, v181v2, t, "equal-slice-v181-p-len")
+		v181va = [8]int{} // clear the array
+		v181v2 = v181va[:]
+		testUnmarshalErr(&v181v2, bs181, h, t, "dec-slice-v181-p-cap")
+		testDeepEqualErr(v181v1, v181v2, t, "equal-slice-v181-p-cap")
+		if len(v181v1) > 1 {
+			v181va = [8]int{} // clear the array
+			testUnmarshalErr((&v181va)[:len(v181v1)], bs181, h, t, "dec-slice-v181-p-len-noaddr")
+			testDeepEqualErr(v181v1, v181va[:len(v181v1)], t, "equal-slice-v181-p-len-noaddr")
+			v181va = [8]int{} // clear the array
+			testUnmarshalErr((&v181va)[:], bs181, h, t, "dec-slice-v181-p-cap-noaddr")
+			testDeepEqualErr(v181v1, v181va[:len(v181v1)], t, "equal-slice-v181-p-cap-noaddr")
+		}
+		// ...
+		var v181v3, v181v4 typMbsSliceInt
+		v181v2 = nil
+		if v != nil {
+			v181v2 = make([]int, len(v))
+		}
+		v181v3 = typMbsSliceInt(v181v1)
+		v181v4 = typMbsSliceInt(v181v2)
+		bs181 = testMarshalErr(v181v3, h, t, "enc-slice-v181-custom")
+		testUnmarshalErr(v181v4, bs181, h, t, "dec-slice-v181-custom")
+		testDeepEqualErr(v181v3, v181v4, t, "equal-slice-v181-custom")
+		bs181 = testMarshalErr(&v181v3, h, t, "enc-slice-v181-custom-p")
+		v181v2 = nil
+		v181v4 = typMbsSliceInt(v181v2)
+		testUnmarshalErr(&v181v4, bs181, h, t, "dec-slice-v181-custom-p")
+		testDeepEqualErr(v181v3, v181v4, t, "equal-slice-v181-custom-p")
+	}
+
+	var v199va [8]int8
+	for _, v := range [][]int8{nil, {}, {44, 0, 0, 33}} {
+		var v199v1, v199v2 []int8
+		v199v1 = v
+		bs199 := testMarshalErr(v199v1, h, t, "enc-slice-v199")
+		if v == nil {
+			v199v2 = nil
+		} else {
+			v199v2 = make([]int8, len(v))
+		}
+		testUnmarshalErr(v199v2, bs199, h, t, "dec-slice-v199")
+		testDeepEqualErr(v199v1, v199v2, t, "equal-slice-v199")
+		if v == nil {
+			v199v2 = nil
+		} else {
+			v199v2 = make([]int8, len(v))
+		}
+		testUnmarshalErr(reflect.ValueOf(v199v2), bs199, h, t, "dec-slice-v199-noaddr") // non-addressable value
+		testDeepEqualErr(v199v1, v199v2, t, "equal-slice-v199-noaddr")
+		// ...
+		bs199 = testMarshalErr(&v199v1, h, t, "enc-slice-v199-p")
+		v199v2 = nil
+		testUnmarshalErr(&v199v2, bs199, h, t, "dec-slice-v199-p")
+		testDeepEqualErr(v199v1, v199v2, t, "equal-slice-v199-p")
+		v199va = [8]int8{} // clear the array
+		v199v2 = v199va[:1:1]
+		testUnmarshalErr(&v199v2, bs199, h, t, "dec-slice-v199-p-1")
+		testDeepEqualErr(v199v1, v199v2, t, "equal-slice-v199-p-1")
+		v199va = [8]int8{} // clear the array
+		v199v2 = v199va[:len(v199v1):len(v199v1)]
+		testUnmarshalErr(&v199v2, bs199, h, t, "dec-slice-v199-p-len")
+		testDeepEqualErr(v199v1, v199v2, t, "equal-slice-v199-p-len")
+		v199va = [8]int8{} // clear the array
+		v199v2 = v199va[:]
+		testUnmarshalErr(&v199v2, bs199, h, t, "dec-slice-v199-p-cap")
+		testDeepEqualErr(v199v1, v199v2, t, "equal-slice-v199-p-cap")
+		if len(v199v1) > 1 {
+			v199va = [8]int8{} // clear the array
+			testUnmarshalErr((&v199va)[:len(v199v1)], bs199, h, t, "dec-slice-v199-p-len-noaddr")
+			testDeepEqualErr(v199v1, v199va[:len(v199v1)], t, "equal-slice-v199-p-len-noaddr")
+			v199va = [8]int8{} // clear the array
+			testUnmarshalErr((&v199va)[:], bs199, h, t, "dec-slice-v199-p-cap-noaddr")
+			testDeepEqualErr(v199v1, v199va[:len(v199v1)], t, "equal-slice-v199-p-cap-noaddr")
+		}
+		// ...
+		var v199v3, v199v4 typMbsSliceInt8
+		v199v2 = nil
+		if v != nil {
+			v199v2 = make([]int8, len(v))
+		}
+		v199v3 = typMbsSliceInt8(v199v1)
+		v199v4 = typMbsSliceInt8(v199v2)
+		bs199 = testMarshalErr(v199v3, h, t, "enc-slice-v199-custom")
+		testUnmarshalErr(v199v4, bs199, h, t, "dec-slice-v199-custom")
+		testDeepEqualErr(v199v3, v199v4, t, "equal-slice-v199-custom")
+		bs199 = testMarshalErr(&v199v3, h, t, "enc-slice-v199-custom-p")
+		v199v2 = nil
+		v199v4 = typMbsSliceInt8(v199v2)
+		testUnmarshalErr(&v199v4, bs199, h, t, "dec-slice-v199-custom-p")
+		testDeepEqualErr(v199v3, v199v4, t, "equal-slice-v199-custom-p")
+	}
+
+	var v217va [8]int16
+	for _, v := range [][]int16{nil, {}, {44, 0, 0, 33}} {
+		var v217v1, v217v2 []int16
+		v217v1 = v
+		bs217 := testMarshalErr(v217v1, h, t, "enc-slice-v217")
+		if v == nil {
+			v217v2 = nil
+		} else {
+			v217v2 = make([]int16, len(v))
+		}
+		testUnmarshalErr(v217v2, bs217, h, t, "dec-slice-v217")
+		testDeepEqualErr(v217v1, v217v2, t, "equal-slice-v217")
+		if v == nil {
+			v217v2 = nil
+		} else {
+			v217v2 = make([]int16, len(v))
+		}
+		testUnmarshalErr(reflect.ValueOf(v217v2), bs217, h, t, "dec-slice-v217-noaddr") // non-addressable value
+		testDeepEqualErr(v217v1, v217v2, t, "equal-slice-v217-noaddr")
+		// ...
+		bs217 = testMarshalErr(&v217v1, h, t, "enc-slice-v217-p")
+		v217v2 = nil
+		testUnmarshalErr(&v217v2, bs217, h, t, "dec-slice-v217-p")
+		testDeepEqualErr(v217v1, v217v2, t, "equal-slice-v217-p")
+		v217va = [8]int16{} // clear the array
+		v217v2 = v217va[:1:1]
+		testUnmarshalErr(&v217v2, bs217, h, t, "dec-slice-v217-p-1")
+		testDeepEqualErr(v217v1, v217v2, t, "equal-slice-v217-p-1")
+		v217va = [8]int16{} // clear the array
+		v217v2 = v217va[:len(v217v1):len(v217v1)]
+		testUnmarshalErr(&v217v2, bs217, h, t, "dec-slice-v217-p-len")
+		testDeepEqualErr(v217v1, v217v2, t, "equal-slice-v217-p-len")
+		v217va = [8]int16{} // clear the array
+		v217v2 = v217va[:]
+		testUnmarshalErr(&v217v2, bs217, h, t, "dec-slice-v217-p-cap")
+		testDeepEqualErr(v217v1, v217v2, t, "equal-slice-v217-p-cap")
+		if len(v217v1) > 1 {
+			v217va = [8]int16{} // clear the array
+			testUnmarshalErr((&v217va)[:len(v217v1)], bs217, h, t, "dec-slice-v217-p-len-noaddr")
+			testDeepEqualErr(v217v1, v217va[:len(v217v1)], t, "equal-slice-v217-p-len-noaddr")
+			v217va = [8]int16{} // clear the array
+			testUnmarshalErr((&v217va)[:], bs217, h, t, "dec-slice-v217-p-cap-noaddr")
+			testDeepEqualErr(v217v1, v217va[:len(v217v1)], t, "equal-slice-v217-p-cap-noaddr")
+		}
+		// ...
+		var v217v3, v217v4 typMbsSliceInt16
+		v217v2 = nil
+		if v != nil {
+			v217v2 = make([]int16, len(v))
+		}
+		v217v3 = typMbsSliceInt16(v217v1)
+		v217v4 = typMbsSliceInt16(v217v2)
+		bs217 = testMarshalErr(v217v3, h, t, "enc-slice-v217-custom")
+		testUnmarshalErr(v217v4, bs217, h, t, "dec-slice-v217-custom")
+		testDeepEqualErr(v217v3, v217v4, t, "equal-slice-v217-custom")
+		bs217 = testMarshalErr(&v217v3, h, t, "enc-slice-v217-custom-p")
+		v217v2 = nil
+		v217v4 = typMbsSliceInt16(v217v2)
+		testUnmarshalErr(&v217v4, bs217, h, t, "dec-slice-v217-custom-p")
+		testDeepEqualErr(v217v3, v217v4, t, "equal-slice-v217-custom-p")
+	}
+
+	var v235va [8]int32
+	for _, v := range [][]int32{nil, {}, {44, 0, 0, 33}} {
+		var v235v1, v235v2 []int32
+		v235v1 = v
+		bs235 := testMarshalErr(v235v1, h, t, "enc-slice-v235")
+		if v == nil {
+			v235v2 = nil
+		} else {
+			v235v2 = make([]int32, len(v))
+		}
+		testUnmarshalErr(v235v2, bs235, h, t, "dec-slice-v235")
+		testDeepEqualErr(v235v1, v235v2, t, "equal-slice-v235")
+		if v == nil {
+			v235v2 = nil
+		} else {
+			v235v2 = make([]int32, len(v))
+		}
+		testUnmarshalErr(reflect.ValueOf(v235v2), bs235, h, t, "dec-slice-v235-noaddr") // non-addressable value
+		testDeepEqualErr(v235v1, v235v2, t, "equal-slice-v235-noaddr")
+		// ...
+		bs235 = testMarshalErr(&v235v1, h, t, "enc-slice-v235-p")
+		v235v2 = nil
+		testUnmarshalErr(&v235v2, bs235, h, t, "dec-slice-v235-p")
+		testDeepEqualErr(v235v1, v235v2, t, "equal-slice-v235-p")
+		v235va = [8]int32{} // clear the array
+		v235v2 = v235va[:1:1]
+		testUnmarshalErr(&v235v2, bs235, h, t, "dec-slice-v235-p-1")
+		testDeepEqualErr(v235v1, v235v2, t, "equal-slice-v235-p-1")
+		v235va = [8]int32{} // clear the array
+		v235v2 = v235va[:len(v235v1):len(v235v1)]
+		testUnmarshalErr(&v235v2, bs235, h, t, "dec-slice-v235-p-len")
+		testDeepEqualErr(v235v1, v235v2, t, "equal-slice-v235-p-len")
+		v235va = [8]int32{} // clear the array
+		v235v2 = v235va[:]
+		testUnmarshalErr(&v235v2, bs235, h, t, "dec-slice-v235-p-cap")
+		testDeepEqualErr(v235v1, v235v2, t, "equal-slice-v235-p-cap")
+		if len(v235v1) > 1 {
+			v235va = [8]int32{} // clear the array
+			testUnmarshalErr((&v235va)[:len(v235v1)], bs235, h, t, "dec-slice-v235-p-len-noaddr")
+			testDeepEqualErr(v235v1, v235va[:len(v235v1)], t, "equal-slice-v235-p-len-noaddr")
+			v235va = [8]int32{} // clear the array
+			testUnmarshalErr((&v235va)[:], bs235, h, t, "dec-slice-v235-p-cap-noaddr")
+			testDeepEqualErr(v235v1, v235va[:len(v235v1)], t, "equal-slice-v235-p-cap-noaddr")
+		}
+		// ...
+		var v235v3, v235v4 typMbsSliceInt32
+		v235v2 = nil
+		if v != nil {
+			v235v2 = make([]int32, len(v))
+		}
+		v235v3 = typMbsSliceInt32(v235v1)
+		v235v4 = typMbsSliceInt32(v235v2)
+		bs235 = testMarshalErr(v235v3, h, t, "enc-slice-v235-custom")
+		testUnmarshalErr(v235v4, bs235, h, t, "dec-slice-v235-custom")
+		testDeepEqualErr(v235v3, v235v4, t, "equal-slice-v235-custom")
+		bs235 = testMarshalErr(&v235v3, h, t, "enc-slice-v235-custom-p")
+		v235v2 = nil
+		v235v4 = typMbsSliceInt32(v235v2)
+		testUnmarshalErr(&v235v4, bs235, h, t, "dec-slice-v235-custom-p")
+		testDeepEqualErr(v235v3, v235v4, t, "equal-slice-v235-custom-p")
+	}
+
+	var v253va [8]int64
+	for _, v := range [][]int64{nil, {}, {44, 0, 0, 33}} {
+		var v253v1, v253v2 []int64
+		v253v1 = v
+		bs253 := testMarshalErr(v253v1, h, t, "enc-slice-v253")
+		if v == nil {
+			v253v2 = nil
+		} else {
+			v253v2 = make([]int64, len(v))
+		}
+		testUnmarshalErr(v253v2, bs253, h, t, "dec-slice-v253")
+		testDeepEqualErr(v253v1, v253v2, t, "equal-slice-v253")
+		if v == nil {
+			v253v2 = nil
+		} else {
+			v253v2 = make([]int64, len(v))
+		}
+		testUnmarshalErr(reflect.ValueOf(v253v2), bs253, h, t, "dec-slice-v253-noaddr") // non-addressable value
+		testDeepEqualErr(v253v1, v253v2, t, "equal-slice-v253-noaddr")
+		// ...
+		bs253 = testMarshalErr(&v253v1, h, t, "enc-slice-v253-p")
+		v253v2 = nil
+		testUnmarshalErr(&v253v2, bs253, h, t, "dec-slice-v253-p")
+		testDeepEqualErr(v253v1, v253v2, t, "equal-slice-v253-p")
+		v253va = [8]int64{} // clear the array
+		v253v2 = v253va[:1:1]
+		testUnmarshalErr(&v253v2, bs253, h, t, "dec-slice-v253-p-1")
+		testDeepEqualErr(v253v1, v253v2, t, "equal-slice-v253-p-1")
+		v253va = [8]int64{} // clear the array
+		v253v2 = v253va[:len(v253v1):len(v253v1)]
+		testUnmarshalErr(&v253v2, bs253, h, t, "dec-slice-v253-p-len")
+		testDeepEqualErr(v253v1, v253v2, t, "equal-slice-v253-p-len")
+		v253va = [8]int64{} // clear the array
+		v253v2 = v253va[:]
+		testUnmarshalErr(&v253v2, bs253, h, t, "dec-slice-v253-p-cap")
+		testDeepEqualErr(v253v1, v253v2, t, "equal-slice-v253-p-cap")
+		if len(v253v1) > 1 {
+			v253va = [8]int64{} // clear the array
+			testUnmarshalErr((&v253va)[:len(v253v1)], bs253, h, t, "dec-slice-v253-p-len-noaddr")
+			testDeepEqualErr(v253v1, v253va[:len(v253v1)], t, "equal-slice-v253-p-len-noaddr")
+			v253va = [8]int64{} // clear the array
+			testUnmarshalErr((&v253va)[:], bs253, h, t, "dec-slice-v253-p-cap-noaddr")
+			testDeepEqualErr(v253v1, v253va[:len(v253v1)], t, "equal-slice-v253-p-cap-noaddr")
+		}
+		// ...
+		var v253v3, v253v4 typMbsSliceInt64
+		v253v2 = nil
+		if v != nil {
+			v253v2 = make([]int64, len(v))
+		}
+		v253v3 = typMbsSliceInt64(v253v1)
+		v253v4 = typMbsSliceInt64(v253v2)
+		bs253 = testMarshalErr(v253v3, h, t, "enc-slice-v253-custom")
+		testUnmarshalErr(v253v4, bs253, h, t, "dec-slice-v253-custom")
+		testDeepEqualErr(v253v3, v253v4, t, "equal-slice-v253-custom")
+		bs253 = testMarshalErr(&v253v3, h, t, "enc-slice-v253-custom-p")
+		v253v2 = nil
+		v253v4 = typMbsSliceInt64(v253v2)
+		testUnmarshalErr(&v253v4, bs253, h, t, "dec-slice-v253-custom-p")
+		testDeepEqualErr(v253v3, v253v4, t, "equal-slice-v253-custom-p")
+	}
+
+	var v271va [8]bool
+	for _, v := range [][]bool{nil, {}, {true, false, false, true}} {
+		var v271v1, v271v2 []bool
+		v271v1 = v
+		bs271 := testMarshalErr(v271v1, h, t, "enc-slice-v271")
+		if v == nil {
+			v271v2 = nil
+		} else {
+			v271v2 = make([]bool, len(v))
+		}
+		testUnmarshalErr(v271v2, bs271, h, t, "dec-slice-v271")
+		testDeepEqualErr(v271v1, v271v2, t, "equal-slice-v271")
+		if v == nil {
+			v271v2 = nil
+		} else {
+			v271v2 = make([]bool, len(v))
+		}
+		testUnmarshalErr(reflect.ValueOf(v271v2), bs271, h, t, "dec-slice-v271-noaddr") // non-addressable value
+		testDeepEqualErr(v271v1, v271v2, t, "equal-slice-v271-noaddr")
+		// ...
+		bs271 = testMarshalErr(&v271v1, h, t, "enc-slice-v271-p")
+		v271v2 = nil
+		testUnmarshalErr(&v271v2, bs271, h, t, "dec-slice-v271-p")
+		testDeepEqualErr(v271v1, v271v2, t, "equal-slice-v271-p")
+		v271va = [8]bool{} // clear the array
+		v271v2 = v271va[:1:1]
+		testUnmarshalErr(&v271v2, bs271, h, t, "dec-slice-v271-p-1")
+		testDeepEqualErr(v271v1, v271v2, t, "equal-slice-v271-p-1")
+		v271va = [8]bool{} // clear the array
+		v271v2 = v271va[:len(v271v1):len(v271v1)]
+		testUnmarshalErr(&v271v2, bs271, h, t, "dec-slice-v271-p-len")
+		testDeepEqualErr(v271v1, v271v2, t, "equal-slice-v271-p-len")
+		v271va = [8]bool{} // clear the array
+		v271v2 = v271va[:]
+		testUnmarshalErr(&v271v2, bs271, h, t, "dec-slice-v271-p-cap")
+		testDeepEqualErr(v271v1, v271v2, t, "equal-slice-v271-p-cap")
+		if len(v271v1) > 1 {
+			v271va = [8]bool{} // clear the array
+			testUnmarshalErr((&v271va)[:len(v271v1)], bs271, h, t, "dec-slice-v271-p-len-noaddr")
+			testDeepEqualErr(v271v1, v271va[:len(v271v1)], t, "equal-slice-v271-p-len-noaddr")
+			v271va = [8]bool{} // clear the array
+			testUnmarshalErr((&v271va)[:], bs271, h, t, "dec-slice-v271-p-cap-noaddr")
+			testDeepEqualErr(v271v1, v271va[:len(v271v1)], t, "equal-slice-v271-p-cap-noaddr")
+		}
+		// ...
+		var v271v3, v271v4 typMbsSliceBool
+		v271v2 = nil
+		if v != nil {
+			v271v2 = make([]bool, len(v))
+		}
+		v271v3 = typMbsSliceBool(v271v1)
+		v271v4 = typMbsSliceBool(v271v2)
+		bs271 = testMarshalErr(v271v3, h, t, "enc-slice-v271-custom")
+		testUnmarshalErr(v271v4, bs271, h, t, "dec-slice-v271-custom")
+		testDeepEqualErr(v271v3, v271v4, t, "equal-slice-v271-custom")
+		bs271 = testMarshalErr(&v271v3, h, t, "enc-slice-v271-custom-p")
+		v271v2 = nil
+		v271v4 = typMbsSliceBool(v271v2)
+		testUnmarshalErr(&v271v4, bs271, h, t, "dec-slice-v271-custom-p")
+		testDeepEqualErr(v271v3, v271v4, t, "equal-slice-v271-custom-p")
+	}
+
+}
+
+func doTestMammothMaps(t *testing.T, h Handle) {
+
+	for _, v := range []map[interface{}]interface{}{nil, {}, {"string-is-an-interface-2": nil, "string-is-an-interface": "string-is-an-interface-2"}} {
+		// 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 = nil
+		} else {
+			v2v2 = make(map[interface{}]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(v2v2, bs2, h, t, "dec-map-v2")
+		testDeepEqualErr(v2v1, v2v2, t, "equal-map-v2")
+		if v == nil {
+			v2v2 = nil
+		} else {
+			v2v2 = make(map[interface{}]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v2v2), bs2, h, t, "dec-map-v2-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v2v1, v2v2, t, "equal-map-v2-noaddr")
+		if v == nil {
+			v2v2 = nil
+		} else {
+			v2v2 = make(map[interface{}]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(&v2v2, bs2, h, t, "dec-map-v2-p-len")
+		testDeepEqualErr(v2v1, v2v2, t, "equal-map-v2-p-len")
+		bs2 = testMarshalErr(&v2v1, h, t, "enc-map-v2-p")
+		v2v2 = nil
+		testUnmarshalErr(&v2v2, bs2, h, t, "dec-map-v2-p-nil")
+		testDeepEqualErr(v2v1, v2v2, t, "equal-map-v2-p-nil")
+		// ...
+		if v == nil {
+			v2v2 = nil
+		} else {
+			v2v2 = make(map[interface{}]interface{}, len(v))
+		} // reset map
+		var v2v3, v2v4 typMapMapIntfIntf
+		v2v3 = typMapMapIntfIntf(v2v1)
+		v2v4 = typMapMapIntfIntf(v2v2)
+		bs2 = testMarshalErr(v2v3, h, t, "enc-map-v2-custom")
+		testUnmarshalErr(v2v4, bs2, h, t, "dec-map-v2-p-len")
+		testDeepEqualErr(v2v3, v2v4, t, "equal-map-v2-p-len")
+	}
+
+	for _, v := range []map[interface{}]string{nil, {}, {"string-is-an-interface": "", "string-is-an-interface-2": "some-string-2"}} {
+		// 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 = nil
+		} else {
+			v3v2 = make(map[interface{}]string, len(v))
+		} // reset map
+		testUnmarshalErr(v3v2, bs3, h, t, "dec-map-v3")
+		testDeepEqualErr(v3v1, v3v2, t, "equal-map-v3")
+		if v == nil {
+			v3v2 = nil
+		} else {
+			v3v2 = make(map[interface{}]string, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v3v2), bs3, h, t, "dec-map-v3-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v3v1, v3v2, t, "equal-map-v3-noaddr")
+		if v == nil {
+			v3v2 = nil
+		} else {
+			v3v2 = make(map[interface{}]string, len(v))
+		} // reset map
+		testUnmarshalErr(&v3v2, bs3, h, t, "dec-map-v3-p-len")
+		testDeepEqualErr(v3v1, v3v2, t, "equal-map-v3-p-len")
+		bs3 = testMarshalErr(&v3v1, h, t, "enc-map-v3-p")
+		v3v2 = nil
+		testUnmarshalErr(&v3v2, bs3, h, t, "dec-map-v3-p-nil")
+		testDeepEqualErr(v3v1, v3v2, t, "equal-map-v3-p-nil")
+		// ...
+		if v == nil {
+			v3v2 = nil
+		} else {
+			v3v2 = make(map[interface{}]string, len(v))
+		} // reset map
+		var v3v3, v3v4 typMapMapIntfString
+		v3v3 = typMapMapIntfString(v3v1)
+		v3v4 = typMapMapIntfString(v3v2)
+		bs3 = testMarshalErr(v3v3, h, t, "enc-map-v3-custom")
+		testUnmarshalErr(v3v4, bs3, h, t, "dec-map-v3-p-len")
+		testDeepEqualErr(v3v3, v3v4, t, "equal-map-v3-p-len")
+	}
+
+	for _, v := range []map[interface{}]uint{nil, {}, {"string-is-an-interface": 0, "string-is-an-interface-2": 44}} {
+		// 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 = nil
+		} else {
+			v4v2 = make(map[interface{}]uint, len(v))
+		} // reset map
+		testUnmarshalErr(v4v2, bs4, h, t, "dec-map-v4")
+		testDeepEqualErr(v4v1, v4v2, t, "equal-map-v4")
+		if v == nil {
+			v4v2 = nil
+		} else {
+			v4v2 = make(map[interface{}]uint, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v4v2), bs4, h, t, "dec-map-v4-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v4v1, v4v2, t, "equal-map-v4-noaddr")
+		if v == nil {
+			v4v2 = nil
+		} else {
+			v4v2 = make(map[interface{}]uint, len(v))
+		} // reset map
+		testUnmarshalErr(&v4v2, bs4, h, t, "dec-map-v4-p-len")
+		testDeepEqualErr(v4v1, v4v2, t, "equal-map-v4-p-len")
+		bs4 = testMarshalErr(&v4v1, h, t, "enc-map-v4-p")
+		v4v2 = nil
+		testUnmarshalErr(&v4v2, bs4, h, t, "dec-map-v4-p-nil")
+		testDeepEqualErr(v4v1, v4v2, t, "equal-map-v4-p-nil")
+		// ...
+		if v == nil {
+			v4v2 = nil
+		} else {
+			v4v2 = make(map[interface{}]uint, len(v))
+		} // reset map
+		var v4v3, v4v4 typMapMapIntfUint
+		v4v3 = typMapMapIntfUint(v4v1)
+		v4v4 = typMapMapIntfUint(v4v2)
+		bs4 = testMarshalErr(v4v3, h, t, "enc-map-v4-custom")
+		testUnmarshalErr(v4v4, bs4, h, t, "dec-map-v4-p-len")
+		testDeepEqualErr(v4v3, v4v4, t, "equal-map-v4-p-len")
+	}
+
+	for _, v := range []map[interface{}]uint8{nil, {}, {"string-is-an-interface": 0, "string-is-an-interface-2": 33}} {
+		// 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 = nil
+		} else {
+			v5v2 = make(map[interface{}]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(v5v2, bs5, h, t, "dec-map-v5")
+		testDeepEqualErr(v5v1, v5v2, t, "equal-map-v5")
+		if v == nil {
+			v5v2 = nil
+		} else {
+			v5v2 = make(map[interface{}]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v5v2), bs5, h, t, "dec-map-v5-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v5v1, v5v2, t, "equal-map-v5-noaddr")
+		if v == nil {
+			v5v2 = nil
+		} else {
+			v5v2 = make(map[interface{}]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(&v5v2, bs5, h, t, "dec-map-v5-p-len")
+		testDeepEqualErr(v5v1, v5v2, t, "equal-map-v5-p-len")
+		bs5 = testMarshalErr(&v5v1, h, t, "enc-map-v5-p")
+		v5v2 = nil
+		testUnmarshalErr(&v5v2, bs5, h, t, "dec-map-v5-p-nil")
+		testDeepEqualErr(v5v1, v5v2, t, "equal-map-v5-p-nil")
+		// ...
+		if v == nil {
+			v5v2 = nil
+		} else {
+			v5v2 = make(map[interface{}]uint8, len(v))
+		} // reset map
+		var v5v3, v5v4 typMapMapIntfUint8
+		v5v3 = typMapMapIntfUint8(v5v1)
+		v5v4 = typMapMapIntfUint8(v5v2)
+		bs5 = testMarshalErr(v5v3, h, t, "enc-map-v5-custom")
+		testUnmarshalErr(v5v4, bs5, h, t, "dec-map-v5-p-len")
+		testDeepEqualErr(v5v3, v5v4, t, "equal-map-v5-p-len")
+	}
+
+	for _, v := range []map[interface{}]uint16{nil, {}, {"string-is-an-interface": 0, "string-is-an-interface-2": 44}} {
+		// 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 = nil
+		} else {
+			v6v2 = make(map[interface{}]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(v6v2, bs6, h, t, "dec-map-v6")
+		testDeepEqualErr(v6v1, v6v2, t, "equal-map-v6")
+		if v == nil {
+			v6v2 = nil
+		} else {
+			v6v2 = make(map[interface{}]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v6v2), bs6, h, t, "dec-map-v6-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v6v1, v6v2, t, "equal-map-v6-noaddr")
+		if v == nil {
+			v6v2 = nil
+		} else {
+			v6v2 = make(map[interface{}]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(&v6v2, bs6, h, t, "dec-map-v6-p-len")
+		testDeepEqualErr(v6v1, v6v2, t, "equal-map-v6-p-len")
+		bs6 = testMarshalErr(&v6v1, h, t, "enc-map-v6-p")
+		v6v2 = nil
+		testUnmarshalErr(&v6v2, bs6, h, t, "dec-map-v6-p-nil")
+		testDeepEqualErr(v6v1, v6v2, t, "equal-map-v6-p-nil")
+		// ...
+		if v == nil {
+			v6v2 = nil
+		} else {
+			v6v2 = make(map[interface{}]uint16, len(v))
+		} // reset map
+		var v6v3, v6v4 typMapMapIntfUint16
+		v6v3 = typMapMapIntfUint16(v6v1)
+		v6v4 = typMapMapIntfUint16(v6v2)
+		bs6 = testMarshalErr(v6v3, h, t, "enc-map-v6-custom")
+		testUnmarshalErr(v6v4, bs6, h, t, "dec-map-v6-p-len")
+		testDeepEqualErr(v6v3, v6v4, t, "equal-map-v6-p-len")
+	}
+
+	for _, v := range []map[interface{}]uint32{nil, {}, {"string-is-an-interface": 0, "string-is-an-interface-2": 33}} {
+		// 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 = nil
+		} else {
+			v7v2 = make(map[interface{}]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(v7v2, bs7, h, t, "dec-map-v7")
+		testDeepEqualErr(v7v1, v7v2, t, "equal-map-v7")
+		if v == nil {
+			v7v2 = nil
+		} else {
+			v7v2 = make(map[interface{}]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v7v2), bs7, h, t, "dec-map-v7-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v7v1, v7v2, t, "equal-map-v7-noaddr")
+		if v == nil {
+			v7v2 = nil
+		} else {
+			v7v2 = make(map[interface{}]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(&v7v2, bs7, h, t, "dec-map-v7-p-len")
+		testDeepEqualErr(v7v1, v7v2, t, "equal-map-v7-p-len")
+		bs7 = testMarshalErr(&v7v1, h, t, "enc-map-v7-p")
+		v7v2 = nil
+		testUnmarshalErr(&v7v2, bs7, h, t, "dec-map-v7-p-nil")
+		testDeepEqualErr(v7v1, v7v2, t, "equal-map-v7-p-nil")
+		// ...
+		if v == nil {
+			v7v2 = nil
+		} else {
+			v7v2 = make(map[interface{}]uint32, len(v))
+		} // reset map
+		var v7v3, v7v4 typMapMapIntfUint32
+		v7v3 = typMapMapIntfUint32(v7v1)
+		v7v4 = typMapMapIntfUint32(v7v2)
+		bs7 = testMarshalErr(v7v3, h, t, "enc-map-v7-custom")
+		testUnmarshalErr(v7v4, bs7, h, t, "dec-map-v7-p-len")
+		testDeepEqualErr(v7v3, v7v4, t, "equal-map-v7-p-len")
+	}
+
+	for _, v := range []map[interface{}]uint64{nil, {}, {"string-is-an-interface": 0, "string-is-an-interface-2": 44}} {
+		// 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 = nil
+		} else {
+			v8v2 = make(map[interface{}]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(v8v2, bs8, h, t, "dec-map-v8")
+		testDeepEqualErr(v8v1, v8v2, t, "equal-map-v8")
+		if v == nil {
+			v8v2 = nil
+		} else {
+			v8v2 = make(map[interface{}]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v8v2), bs8, h, t, "dec-map-v8-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v8v1, v8v2, t, "equal-map-v8-noaddr")
+		if v == nil {
+			v8v2 = nil
+		} else {
+			v8v2 = make(map[interface{}]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(&v8v2, bs8, h, t, "dec-map-v8-p-len")
+		testDeepEqualErr(v8v1, v8v2, t, "equal-map-v8-p-len")
+		bs8 = testMarshalErr(&v8v1, h, t, "enc-map-v8-p")
+		v8v2 = nil
+		testUnmarshalErr(&v8v2, bs8, h, t, "dec-map-v8-p-nil")
+		testDeepEqualErr(v8v1, v8v2, t, "equal-map-v8-p-nil")
+		// ...
+		if v == nil {
+			v8v2 = nil
+		} else {
+			v8v2 = make(map[interface{}]uint64, len(v))
+		} // reset map
+		var v8v3, v8v4 typMapMapIntfUint64
+		v8v3 = typMapMapIntfUint64(v8v1)
+		v8v4 = typMapMapIntfUint64(v8v2)
+		bs8 = testMarshalErr(v8v3, h, t, "enc-map-v8-custom")
+		testUnmarshalErr(v8v4, bs8, h, t, "dec-map-v8-p-len")
+		testDeepEqualErr(v8v3, v8v4, t, "equal-map-v8-p-len")
+	}
+
+	for _, v := range []map[interface{}]uintptr{nil, {}, {"string-is-an-interface": 0, "string-is-an-interface-2": 33}} {
+		// 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 = nil
+		} else {
+			v9v2 = make(map[interface{}]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(v9v2, bs9, h, t, "dec-map-v9")
+		testDeepEqualErr(v9v1, v9v2, t, "equal-map-v9")
+		if v == nil {
+			v9v2 = nil
+		} else {
+			v9v2 = make(map[interface{}]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v9v2), bs9, h, t, "dec-map-v9-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v9v1, v9v2, t, "equal-map-v9-noaddr")
+		if v == nil {
+			v9v2 = nil
+		} else {
+			v9v2 = make(map[interface{}]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(&v9v2, bs9, h, t, "dec-map-v9-p-len")
+		testDeepEqualErr(v9v1, v9v2, t, "equal-map-v9-p-len")
+		bs9 = testMarshalErr(&v9v1, h, t, "enc-map-v9-p")
+		v9v2 = nil
+		testUnmarshalErr(&v9v2, bs9, h, t, "dec-map-v9-p-nil")
+		testDeepEqualErr(v9v1, v9v2, t, "equal-map-v9-p-nil")
+		// ...
+		if v == nil {
+			v9v2 = nil
+		} else {
+			v9v2 = make(map[interface{}]uintptr, len(v))
+		} // reset map
+		var v9v3, v9v4 typMapMapIntfUintptr
+		v9v3 = typMapMapIntfUintptr(v9v1)
+		v9v4 = typMapMapIntfUintptr(v9v2)
+		bs9 = testMarshalErr(v9v3, h, t, "enc-map-v9-custom")
+		testUnmarshalErr(v9v4, bs9, h, t, "dec-map-v9-p-len")
+		testDeepEqualErr(v9v3, v9v4, t, "equal-map-v9-p-len")
+	}
+
+	for _, v := range []map[interface{}]int{nil, {}, {"string-is-an-interface": 0, "string-is-an-interface-2": 44}} {
+		// 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 = nil
+		} else {
+			v10v2 = make(map[interface{}]int, len(v))
+		} // reset map
+		testUnmarshalErr(v10v2, bs10, h, t, "dec-map-v10")
+		testDeepEqualErr(v10v1, v10v2, t, "equal-map-v10")
+		if v == nil {
+			v10v2 = nil
+		} else {
+			v10v2 = make(map[interface{}]int, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v10v2), bs10, h, t, "dec-map-v10-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v10v1, v10v2, t, "equal-map-v10-noaddr")
+		if v == nil {
+			v10v2 = nil
+		} else {
+			v10v2 = make(map[interface{}]int, len(v))
+		} // reset map
+		testUnmarshalErr(&v10v2, bs10, h, t, "dec-map-v10-p-len")
+		testDeepEqualErr(v10v1, v10v2, t, "equal-map-v10-p-len")
+		bs10 = testMarshalErr(&v10v1, h, t, "enc-map-v10-p")
+		v10v2 = nil
+		testUnmarshalErr(&v10v2, bs10, h, t, "dec-map-v10-p-nil")
+		testDeepEqualErr(v10v1, v10v2, t, "equal-map-v10-p-nil")
+		// ...
+		if v == nil {
+			v10v2 = nil
+		} else {
+			v10v2 = make(map[interface{}]int, len(v))
+		} // reset map
+		var v10v3, v10v4 typMapMapIntfInt
+		v10v3 = typMapMapIntfInt(v10v1)
+		v10v4 = typMapMapIntfInt(v10v2)
+		bs10 = testMarshalErr(v10v3, h, t, "enc-map-v10-custom")
+		testUnmarshalErr(v10v4, bs10, h, t, "dec-map-v10-p-len")
+		testDeepEqualErr(v10v3, v10v4, t, "equal-map-v10-p-len")
+	}
+
+	for _, v := range []map[interface{}]int8{nil, {}, {"string-is-an-interface": 0, "string-is-an-interface-2": 33}} {
+		// 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 = nil
+		} else {
+			v11v2 = make(map[interface{}]int8, len(v))
+		} // reset map
+		testUnmarshalErr(v11v2, bs11, h, t, "dec-map-v11")
+		testDeepEqualErr(v11v1, v11v2, t, "equal-map-v11")
+		if v == nil {
+			v11v2 = nil
+		} else {
+			v11v2 = make(map[interface{}]int8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v11v2), bs11, h, t, "dec-map-v11-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v11v1, v11v2, t, "equal-map-v11-noaddr")
+		if v == nil {
+			v11v2 = nil
+		} else {
+			v11v2 = make(map[interface{}]int8, len(v))
+		} // reset map
+		testUnmarshalErr(&v11v2, bs11, h, t, "dec-map-v11-p-len")
+		testDeepEqualErr(v11v1, v11v2, t, "equal-map-v11-p-len")
+		bs11 = testMarshalErr(&v11v1, h, t, "enc-map-v11-p")
+		v11v2 = nil
+		testUnmarshalErr(&v11v2, bs11, h, t, "dec-map-v11-p-nil")
+		testDeepEqualErr(v11v1, v11v2, t, "equal-map-v11-p-nil")
+		// ...
+		if v == nil {
+			v11v2 = nil
+		} else {
+			v11v2 = make(map[interface{}]int8, len(v))
+		} // reset map
+		var v11v3, v11v4 typMapMapIntfInt8
+		v11v3 = typMapMapIntfInt8(v11v1)
+		v11v4 = typMapMapIntfInt8(v11v2)
+		bs11 = testMarshalErr(v11v3, h, t, "enc-map-v11-custom")
+		testUnmarshalErr(v11v4, bs11, h, t, "dec-map-v11-p-len")
+		testDeepEqualErr(v11v3, v11v4, t, "equal-map-v11-p-len")
+	}
+
+	for _, v := range []map[interface{}]int16{nil, {}, {"string-is-an-interface": 0, "string-is-an-interface-2": 44}} {
+		// 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 = nil
+		} else {
+			v12v2 = make(map[interface{}]int16, len(v))
+		} // reset map
+		testUnmarshalErr(v12v2, bs12, h, t, "dec-map-v12")
+		testDeepEqualErr(v12v1, v12v2, t, "equal-map-v12")
+		if v == nil {
+			v12v2 = nil
+		} else {
+			v12v2 = make(map[interface{}]int16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v12v2), bs12, h, t, "dec-map-v12-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v12v1, v12v2, t, "equal-map-v12-noaddr")
+		if v == nil {
+			v12v2 = nil
+		} else {
+			v12v2 = make(map[interface{}]int16, len(v))
+		} // reset map
+		testUnmarshalErr(&v12v2, bs12, h, t, "dec-map-v12-p-len")
+		testDeepEqualErr(v12v1, v12v2, t, "equal-map-v12-p-len")
+		bs12 = testMarshalErr(&v12v1, h, t, "enc-map-v12-p")
+		v12v2 = nil
+		testUnmarshalErr(&v12v2, bs12, h, t, "dec-map-v12-p-nil")
+		testDeepEqualErr(v12v1, v12v2, t, "equal-map-v12-p-nil")
+		// ...
+		if v == nil {
+			v12v2 = nil
+		} else {
+			v12v2 = make(map[interface{}]int16, len(v))
+		} // reset map
+		var v12v3, v12v4 typMapMapIntfInt16
+		v12v3 = typMapMapIntfInt16(v12v1)
+		v12v4 = typMapMapIntfInt16(v12v2)
+		bs12 = testMarshalErr(v12v3, h, t, "enc-map-v12-custom")
+		testUnmarshalErr(v12v4, bs12, h, t, "dec-map-v12-p-len")
+		testDeepEqualErr(v12v3, v12v4, t, "equal-map-v12-p-len")
+	}
+
+	for _, v := range []map[interface{}]int32{nil, {}, {"string-is-an-interface": 0, "string-is-an-interface-2": 33}} {
+		// 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 = nil
+		} else {
+			v13v2 = make(map[interface{}]int32, len(v))
+		} // reset map
+		testUnmarshalErr(v13v2, bs13, h, t, "dec-map-v13")
+		testDeepEqualErr(v13v1, v13v2, t, "equal-map-v13")
+		if v == nil {
+			v13v2 = nil
+		} else {
+			v13v2 = make(map[interface{}]int32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v13v2), bs13, h, t, "dec-map-v13-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v13v1, v13v2, t, "equal-map-v13-noaddr")
+		if v == nil {
+			v13v2 = nil
+		} else {
+			v13v2 = make(map[interface{}]int32, len(v))
+		} // reset map
+		testUnmarshalErr(&v13v2, bs13, h, t, "dec-map-v13-p-len")
+		testDeepEqualErr(v13v1, v13v2, t, "equal-map-v13-p-len")
+		bs13 = testMarshalErr(&v13v1, h, t, "enc-map-v13-p")
+		v13v2 = nil
+		testUnmarshalErr(&v13v2, bs13, h, t, "dec-map-v13-p-nil")
+		testDeepEqualErr(v13v1, v13v2, t, "equal-map-v13-p-nil")
+		// ...
+		if v == nil {
+			v13v2 = nil
+		} else {
+			v13v2 = make(map[interface{}]int32, len(v))
+		} // reset map
+		var v13v3, v13v4 typMapMapIntfInt32
+		v13v3 = typMapMapIntfInt32(v13v1)
+		v13v4 = typMapMapIntfInt32(v13v2)
+		bs13 = testMarshalErr(v13v3, h, t, "enc-map-v13-custom")
+		testUnmarshalErr(v13v4, bs13, h, t, "dec-map-v13-p-len")
+		testDeepEqualErr(v13v3, v13v4, t, "equal-map-v13-p-len")
+	}
+
+	for _, v := range []map[interface{}]int64{nil, {}, {"string-is-an-interface": 0, "string-is-an-interface-2": 44}} {
+		// 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 = nil
+		} else {
+			v14v2 = make(map[interface{}]int64, len(v))
+		} // reset map
+		testUnmarshalErr(v14v2, bs14, h, t, "dec-map-v14")
+		testDeepEqualErr(v14v1, v14v2, t, "equal-map-v14")
+		if v == nil {
+			v14v2 = nil
+		} else {
+			v14v2 = make(map[interface{}]int64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v14v2), bs14, h, t, "dec-map-v14-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v14v1, v14v2, t, "equal-map-v14-noaddr")
+		if v == nil {
+			v14v2 = nil
+		} else {
+			v14v2 = make(map[interface{}]int64, len(v))
+		} // reset map
+		testUnmarshalErr(&v14v2, bs14, h, t, "dec-map-v14-p-len")
+		testDeepEqualErr(v14v1, v14v2, t, "equal-map-v14-p-len")
+		bs14 = testMarshalErr(&v14v1, h, t, "enc-map-v14-p")
+		v14v2 = nil
+		testUnmarshalErr(&v14v2, bs14, h, t, "dec-map-v14-p-nil")
+		testDeepEqualErr(v14v1, v14v2, t, "equal-map-v14-p-nil")
+		// ...
+		if v == nil {
+			v14v2 = nil
+		} else {
+			v14v2 = make(map[interface{}]int64, len(v))
+		} // reset map
+		var v14v3, v14v4 typMapMapIntfInt64
+		v14v3 = typMapMapIntfInt64(v14v1)
+		v14v4 = typMapMapIntfInt64(v14v2)
+		bs14 = testMarshalErr(v14v3, h, t, "enc-map-v14-custom")
+		testUnmarshalErr(v14v4, bs14, h, t, "dec-map-v14-p-len")
+		testDeepEqualErr(v14v3, v14v4, t, "equal-map-v14-p-len")
+	}
+
+	for _, v := range []map[interface{}]float32{nil, {}, {"string-is-an-interface": 0, "string-is-an-interface-2": 22.2}} {
+		// 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 = nil
+		} else {
+			v15v2 = make(map[interface{}]float32, len(v))
+		} // reset map
+		testUnmarshalErr(v15v2, bs15, h, t, "dec-map-v15")
+		testDeepEqualErr(v15v1, v15v2, t, "equal-map-v15")
+		if v == nil {
+			v15v2 = nil
+		} else {
+			v15v2 = make(map[interface{}]float32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v15v2), bs15, h, t, "dec-map-v15-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v15v1, v15v2, t, "equal-map-v15-noaddr")
+		if v == nil {
+			v15v2 = nil
+		} else {
+			v15v2 = make(map[interface{}]float32, len(v))
+		} // reset map
+		testUnmarshalErr(&v15v2, bs15, h, t, "dec-map-v15-p-len")
+		testDeepEqualErr(v15v1, v15v2, t, "equal-map-v15-p-len")
+		bs15 = testMarshalErr(&v15v1, h, t, "enc-map-v15-p")
+		v15v2 = nil
+		testUnmarshalErr(&v15v2, bs15, h, t, "dec-map-v15-p-nil")
+		testDeepEqualErr(v15v1, v15v2, t, "equal-map-v15-p-nil")
+		// ...
+		if v == nil {
+			v15v2 = nil
+		} else {
+			v15v2 = make(map[interface{}]float32, len(v))
+		} // reset map
+		var v15v3, v15v4 typMapMapIntfFloat32
+		v15v3 = typMapMapIntfFloat32(v15v1)
+		v15v4 = typMapMapIntfFloat32(v15v2)
+		bs15 = testMarshalErr(v15v3, h, t, "enc-map-v15-custom")
+		testUnmarshalErr(v15v4, bs15, h, t, "dec-map-v15-p-len")
+		testDeepEqualErr(v15v3, v15v4, t, "equal-map-v15-p-len")
+	}
+
+	for _, v := range []map[interface{}]float64{nil, {}, {"string-is-an-interface": 0, "string-is-an-interface-2": 11.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 = nil
+		} else {
+			v16v2 = make(map[interface{}]float64, len(v))
+		} // reset map
+		testUnmarshalErr(v16v2, bs16, h, t, "dec-map-v16")
+		testDeepEqualErr(v16v1, v16v2, t, "equal-map-v16")
+		if v == nil {
+			v16v2 = nil
+		} else {
+			v16v2 = make(map[interface{}]float64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v16v2), bs16, h, t, "dec-map-v16-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v16v1, v16v2, t, "equal-map-v16-noaddr")
+		if v == nil {
+			v16v2 = nil
+		} else {
+			v16v2 = make(map[interface{}]float64, len(v))
+		} // reset map
+		testUnmarshalErr(&v16v2, bs16, h, t, "dec-map-v16-p-len")
+		testDeepEqualErr(v16v1, v16v2, t, "equal-map-v16-p-len")
+		bs16 = testMarshalErr(&v16v1, h, t, "enc-map-v16-p")
+		v16v2 = nil
+		testUnmarshalErr(&v16v2, bs16, h, t, "dec-map-v16-p-nil")
+		testDeepEqualErr(v16v1, v16v2, t, "equal-map-v16-p-nil")
+		// ...
+		if v == nil {
+			v16v2 = nil
+		} else {
+			v16v2 = make(map[interface{}]float64, len(v))
+		} // reset map
+		var v16v3, v16v4 typMapMapIntfFloat64
+		v16v3 = typMapMapIntfFloat64(v16v1)
+		v16v4 = typMapMapIntfFloat64(v16v2)
+		bs16 = testMarshalErr(v16v3, h, t, "enc-map-v16-custom")
+		testUnmarshalErr(v16v4, bs16, h, t, "dec-map-v16-p-len")
+		testDeepEqualErr(v16v3, v16v4, t, "equal-map-v16-p-len")
+	}
+
+	for _, v := range []map[interface{}]bool{nil, {}, {"string-is-an-interface": false, "string-is-an-interface-2": 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 = nil
+		} else {
+			v17v2 = make(map[interface{}]bool, len(v))
+		} // reset map
+		testUnmarshalErr(v17v2, bs17, h, t, "dec-map-v17")
+		testDeepEqualErr(v17v1, v17v2, t, "equal-map-v17")
+		if v == nil {
+			v17v2 = nil
+		} else {
+			v17v2 = make(map[interface{}]bool, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v17v2), bs17, h, t, "dec-map-v17-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v17v1, v17v2, t, "equal-map-v17-noaddr")
+		if v == nil {
+			v17v2 = nil
+		} else {
+			v17v2 = make(map[interface{}]bool, len(v))
+		} // reset map
+		testUnmarshalErr(&v17v2, bs17, h, t, "dec-map-v17-p-len")
+		testDeepEqualErr(v17v1, v17v2, t, "equal-map-v17-p-len")
+		bs17 = testMarshalErr(&v17v1, h, t, "enc-map-v17-p")
+		v17v2 = nil
+		testUnmarshalErr(&v17v2, bs17, h, t, "dec-map-v17-p-nil")
+		testDeepEqualErr(v17v1, v17v2, t, "equal-map-v17-p-nil")
+		// ...
+		if v == nil {
+			v17v2 = nil
+		} else {
+			v17v2 = make(map[interface{}]bool, len(v))
+		} // reset map
+		var v17v3, v17v4 typMapMapIntfBool
+		v17v3 = typMapMapIntfBool(v17v1)
+		v17v4 = typMapMapIntfBool(v17v2)
+		bs17 = testMarshalErr(v17v3, h, t, "enc-map-v17-custom")
+		testUnmarshalErr(v17v4, bs17, h, t, "dec-map-v17-p-len")
+		testDeepEqualErr(v17v3, v17v4, t, "equal-map-v17-p-len")
+	}
+
+	for _, v := range []map[string]interface{}{nil, {}, {"some-string": nil, "some-string-2": "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 = nil
+		} else {
+			v20v2 = make(map[string]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(v20v2, bs20, h, t, "dec-map-v20")
+		testDeepEqualErr(v20v1, v20v2, t, "equal-map-v20")
+		if v == nil {
+			v20v2 = nil
+		} else {
+			v20v2 = make(map[string]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v20v2), bs20, h, t, "dec-map-v20-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v20v1, v20v2, t, "equal-map-v20-noaddr")
+		if v == nil {
+			v20v2 = nil
+		} else {
+			v20v2 = make(map[string]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(&v20v2, bs20, h, t, "dec-map-v20-p-len")
+		testDeepEqualErr(v20v1, v20v2, t, "equal-map-v20-p-len")
+		bs20 = testMarshalErr(&v20v1, h, t, "enc-map-v20-p")
+		v20v2 = nil
+		testUnmarshalErr(&v20v2, bs20, h, t, "dec-map-v20-p-nil")
+		testDeepEqualErr(v20v1, v20v2, t, "equal-map-v20-p-nil")
+		// ...
+		if v == nil {
+			v20v2 = nil
+		} else {
+			v20v2 = make(map[string]interface{}, len(v))
+		} // reset map
+		var v20v3, v20v4 typMapMapStringIntf
+		v20v3 = typMapMapStringIntf(v20v1)
+		v20v4 = typMapMapStringIntf(v20v2)
+		bs20 = testMarshalErr(v20v3, h, t, "enc-map-v20-custom")
+		testUnmarshalErr(v20v4, bs20, h, t, "dec-map-v20-p-len")
+		testDeepEqualErr(v20v3, v20v4, t, "equal-map-v20-p-len")
+	}
+
+	for _, v := range []map[string]string{nil, {}, {"some-string": "", "some-string-2": "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 = nil
+		} else {
+			v21v2 = make(map[string]string, len(v))
+		} // reset map
+		testUnmarshalErr(v21v2, bs21, h, t, "dec-map-v21")
+		testDeepEqualErr(v21v1, v21v2, t, "equal-map-v21")
+		if v == nil {
+			v21v2 = nil
+		} else {
+			v21v2 = make(map[string]string, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v21v2), bs21, h, t, "dec-map-v21-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v21v1, v21v2, t, "equal-map-v21-noaddr")
+		if v == nil {
+			v21v2 = nil
+		} else {
+			v21v2 = make(map[string]string, len(v))
+		} // reset map
+		testUnmarshalErr(&v21v2, bs21, h, t, "dec-map-v21-p-len")
+		testDeepEqualErr(v21v1, v21v2, t, "equal-map-v21-p-len")
+		bs21 = testMarshalErr(&v21v1, h, t, "enc-map-v21-p")
+		v21v2 = nil
+		testUnmarshalErr(&v21v2, bs21, h, t, "dec-map-v21-p-nil")
+		testDeepEqualErr(v21v1, v21v2, t, "equal-map-v21-p-nil")
+		// ...
+		if v == nil {
+			v21v2 = nil
+		} else {
+			v21v2 = make(map[string]string, len(v))
+		} // reset map
+		var v21v3, v21v4 typMapMapStringString
+		v21v3 = typMapMapStringString(v21v1)
+		v21v4 = typMapMapStringString(v21v2)
+		bs21 = testMarshalErr(v21v3, h, t, "enc-map-v21-custom")
+		testUnmarshalErr(v21v4, bs21, h, t, "dec-map-v21-p-len")
+		testDeepEqualErr(v21v3, v21v4, t, "equal-map-v21-p-len")
+	}
+
+	for _, v := range []map[string]uint{nil, {}, {"some-string-2": 0, "some-string": 33}} {
+		// 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 = nil
+		} else {
+			v22v2 = make(map[string]uint, len(v))
+		} // reset map
+		testUnmarshalErr(v22v2, bs22, h, t, "dec-map-v22")
+		testDeepEqualErr(v22v1, v22v2, t, "equal-map-v22")
+		if v == nil {
+			v22v2 = nil
+		} else {
+			v22v2 = make(map[string]uint, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v22v2), bs22, h, t, "dec-map-v22-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v22v1, v22v2, t, "equal-map-v22-noaddr")
+		if v == nil {
+			v22v2 = nil
+		} else {
+			v22v2 = make(map[string]uint, len(v))
+		} // reset map
+		testUnmarshalErr(&v22v2, bs22, h, t, "dec-map-v22-p-len")
+		testDeepEqualErr(v22v1, v22v2, t, "equal-map-v22-p-len")
+		bs22 = testMarshalErr(&v22v1, h, t, "enc-map-v22-p")
+		v22v2 = nil
+		testUnmarshalErr(&v22v2, bs22, h, t, "dec-map-v22-p-nil")
+		testDeepEqualErr(v22v1, v22v2, t, "equal-map-v22-p-nil")
+		// ...
+		if v == nil {
+			v22v2 = nil
+		} else {
+			v22v2 = make(map[string]uint, len(v))
+		} // reset map
+		var v22v3, v22v4 typMapMapStringUint
+		v22v3 = typMapMapStringUint(v22v1)
+		v22v4 = typMapMapStringUint(v22v2)
+		bs22 = testMarshalErr(v22v3, h, t, "enc-map-v22-custom")
+		testUnmarshalErr(v22v4, bs22, h, t, "dec-map-v22-p-len")
+		testDeepEqualErr(v22v3, v22v4, t, "equal-map-v22-p-len")
+	}
+
+	for _, v := range []map[string]uint8{nil, {}, {"some-string-2": 0, "some-string": 44}} {
+		// 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 = nil
+		} else {
+			v23v2 = make(map[string]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(v23v2, bs23, h, t, "dec-map-v23")
+		testDeepEqualErr(v23v1, v23v2, t, "equal-map-v23")
+		if v == nil {
+			v23v2 = nil
+		} else {
+			v23v2 = make(map[string]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v23v2), bs23, h, t, "dec-map-v23-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v23v1, v23v2, t, "equal-map-v23-noaddr")
+		if v == nil {
+			v23v2 = nil
+		} else {
+			v23v2 = make(map[string]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(&v23v2, bs23, h, t, "dec-map-v23-p-len")
+		testDeepEqualErr(v23v1, v23v2, t, "equal-map-v23-p-len")
+		bs23 = testMarshalErr(&v23v1, h, t, "enc-map-v23-p")
+		v23v2 = nil
+		testUnmarshalErr(&v23v2, bs23, h, t, "dec-map-v23-p-nil")
+		testDeepEqualErr(v23v1, v23v2, t, "equal-map-v23-p-nil")
+		// ...
+		if v == nil {
+			v23v2 = nil
+		} else {
+			v23v2 = make(map[string]uint8, len(v))
+		} // reset map
+		var v23v3, v23v4 typMapMapStringUint8
+		v23v3 = typMapMapStringUint8(v23v1)
+		v23v4 = typMapMapStringUint8(v23v2)
+		bs23 = testMarshalErr(v23v3, h, t, "enc-map-v23-custom")
+		testUnmarshalErr(v23v4, bs23, h, t, "dec-map-v23-p-len")
+		testDeepEqualErr(v23v3, v23v4, t, "equal-map-v23-p-len")
+	}
+
+	for _, v := range []map[string]uint16{nil, {}, {"some-string-2": 0, "some-string": 33}} {
+		// 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 = nil
+		} else {
+			v24v2 = make(map[string]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(v24v2, bs24, h, t, "dec-map-v24")
+		testDeepEqualErr(v24v1, v24v2, t, "equal-map-v24")
+		if v == nil {
+			v24v2 = nil
+		} else {
+			v24v2 = make(map[string]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v24v2), bs24, h, t, "dec-map-v24-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v24v1, v24v2, t, "equal-map-v24-noaddr")
+		if v == nil {
+			v24v2 = nil
+		} else {
+			v24v2 = make(map[string]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(&v24v2, bs24, h, t, "dec-map-v24-p-len")
+		testDeepEqualErr(v24v1, v24v2, t, "equal-map-v24-p-len")
+		bs24 = testMarshalErr(&v24v1, h, t, "enc-map-v24-p")
+		v24v2 = nil
+		testUnmarshalErr(&v24v2, bs24, h, t, "dec-map-v24-p-nil")
+		testDeepEqualErr(v24v1, v24v2, t, "equal-map-v24-p-nil")
+		// ...
+		if v == nil {
+			v24v2 = nil
+		} else {
+			v24v2 = make(map[string]uint16, len(v))
+		} // reset map
+		var v24v3, v24v4 typMapMapStringUint16
+		v24v3 = typMapMapStringUint16(v24v1)
+		v24v4 = typMapMapStringUint16(v24v2)
+		bs24 = testMarshalErr(v24v3, h, t, "enc-map-v24-custom")
+		testUnmarshalErr(v24v4, bs24, h, t, "dec-map-v24-p-len")
+		testDeepEqualErr(v24v3, v24v4, t, "equal-map-v24-p-len")
+	}
+
+	for _, v := range []map[string]uint32{nil, {}, {"some-string-2": 0, "some-string": 44}} {
+		// 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 = nil
+		} else {
+			v25v2 = make(map[string]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(v25v2, bs25, h, t, "dec-map-v25")
+		testDeepEqualErr(v25v1, v25v2, t, "equal-map-v25")
+		if v == nil {
+			v25v2 = nil
+		} else {
+			v25v2 = make(map[string]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v25v2), bs25, h, t, "dec-map-v25-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v25v1, v25v2, t, "equal-map-v25-noaddr")
+		if v == nil {
+			v25v2 = nil
+		} else {
+			v25v2 = make(map[string]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(&v25v2, bs25, h, t, "dec-map-v25-p-len")
+		testDeepEqualErr(v25v1, v25v2, t, "equal-map-v25-p-len")
+		bs25 = testMarshalErr(&v25v1, h, t, "enc-map-v25-p")
+		v25v2 = nil
+		testUnmarshalErr(&v25v2, bs25, h, t, "dec-map-v25-p-nil")
+		testDeepEqualErr(v25v1, v25v2, t, "equal-map-v25-p-nil")
+		// ...
+		if v == nil {
+			v25v2 = nil
+		} else {
+			v25v2 = make(map[string]uint32, len(v))
+		} // reset map
+		var v25v3, v25v4 typMapMapStringUint32
+		v25v3 = typMapMapStringUint32(v25v1)
+		v25v4 = typMapMapStringUint32(v25v2)
+		bs25 = testMarshalErr(v25v3, h, t, "enc-map-v25-custom")
+		testUnmarshalErr(v25v4, bs25, h, t, "dec-map-v25-p-len")
+		testDeepEqualErr(v25v3, v25v4, t, "equal-map-v25-p-len")
+	}
+
+	for _, v := range []map[string]uint64{nil, {}, {"some-string-2": 0, "some-string": 33}} {
+		// 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 = nil
+		} else {
+			v26v2 = make(map[string]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(v26v2, bs26, h, t, "dec-map-v26")
+		testDeepEqualErr(v26v1, v26v2, t, "equal-map-v26")
+		if v == nil {
+			v26v2 = nil
+		} else {
+			v26v2 = make(map[string]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v26v2), bs26, h, t, "dec-map-v26-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v26v1, v26v2, t, "equal-map-v26-noaddr")
+		if v == nil {
+			v26v2 = nil
+		} else {
+			v26v2 = make(map[string]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(&v26v2, bs26, h, t, "dec-map-v26-p-len")
+		testDeepEqualErr(v26v1, v26v2, t, "equal-map-v26-p-len")
+		bs26 = testMarshalErr(&v26v1, h, t, "enc-map-v26-p")
+		v26v2 = nil
+		testUnmarshalErr(&v26v2, bs26, h, t, "dec-map-v26-p-nil")
+		testDeepEqualErr(v26v1, v26v2, t, "equal-map-v26-p-nil")
+		// ...
+		if v == nil {
+			v26v2 = nil
+		} else {
+			v26v2 = make(map[string]uint64, len(v))
+		} // reset map
+		var v26v3, v26v4 typMapMapStringUint64
+		v26v3 = typMapMapStringUint64(v26v1)
+		v26v4 = typMapMapStringUint64(v26v2)
+		bs26 = testMarshalErr(v26v3, h, t, "enc-map-v26-custom")
+		testUnmarshalErr(v26v4, bs26, h, t, "dec-map-v26-p-len")
+		testDeepEqualErr(v26v3, v26v4, t, "equal-map-v26-p-len")
+	}
+
+	for _, v := range []map[string]uintptr{nil, {}, {"some-string-2": 0, "some-string": 44}} {
+		// 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 = nil
+		} else {
+			v27v2 = make(map[string]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(v27v2, bs27, h, t, "dec-map-v27")
+		testDeepEqualErr(v27v1, v27v2, t, "equal-map-v27")
+		if v == nil {
+			v27v2 = nil
+		} else {
+			v27v2 = make(map[string]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v27v2), bs27, h, t, "dec-map-v27-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v27v1, v27v2, t, "equal-map-v27-noaddr")
+		if v == nil {
+			v27v2 = nil
+		} else {
+			v27v2 = make(map[string]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(&v27v2, bs27, h, t, "dec-map-v27-p-len")
+		testDeepEqualErr(v27v1, v27v2, t, "equal-map-v27-p-len")
+		bs27 = testMarshalErr(&v27v1, h, t, "enc-map-v27-p")
+		v27v2 = nil
+		testUnmarshalErr(&v27v2, bs27, h, t, "dec-map-v27-p-nil")
+		testDeepEqualErr(v27v1, v27v2, t, "equal-map-v27-p-nil")
+		// ...
+		if v == nil {
+			v27v2 = nil
+		} else {
+			v27v2 = make(map[string]uintptr, len(v))
+		} // reset map
+		var v27v3, v27v4 typMapMapStringUintptr
+		v27v3 = typMapMapStringUintptr(v27v1)
+		v27v4 = typMapMapStringUintptr(v27v2)
+		bs27 = testMarshalErr(v27v3, h, t, "enc-map-v27-custom")
+		testUnmarshalErr(v27v4, bs27, h, t, "dec-map-v27-p-len")
+		testDeepEqualErr(v27v3, v27v4, t, "equal-map-v27-p-len")
+	}
+
+	for _, v := range []map[string]int{nil, {}, {"some-string-2": 0, "some-string": 33}} {
+		// 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 = nil
+		} else {
+			v28v2 = make(map[string]int, len(v))
+		} // reset map
+		testUnmarshalErr(v28v2, bs28, h, t, "dec-map-v28")
+		testDeepEqualErr(v28v1, v28v2, t, "equal-map-v28")
+		if v == nil {
+			v28v2 = nil
+		} else {
+			v28v2 = make(map[string]int, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v28v2), bs28, h, t, "dec-map-v28-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v28v1, v28v2, t, "equal-map-v28-noaddr")
+		if v == nil {
+			v28v2 = nil
+		} else {
+			v28v2 = make(map[string]int, len(v))
+		} // reset map
+		testUnmarshalErr(&v28v2, bs28, h, t, "dec-map-v28-p-len")
+		testDeepEqualErr(v28v1, v28v2, t, "equal-map-v28-p-len")
+		bs28 = testMarshalErr(&v28v1, h, t, "enc-map-v28-p")
+		v28v2 = nil
+		testUnmarshalErr(&v28v2, bs28, h, t, "dec-map-v28-p-nil")
+		testDeepEqualErr(v28v1, v28v2, t, "equal-map-v28-p-nil")
+		// ...
+		if v == nil {
+			v28v2 = nil
+		} else {
+			v28v2 = make(map[string]int, len(v))
+		} // reset map
+		var v28v3, v28v4 typMapMapStringInt
+		v28v3 = typMapMapStringInt(v28v1)
+		v28v4 = typMapMapStringInt(v28v2)
+		bs28 = testMarshalErr(v28v3, h, t, "enc-map-v28-custom")
+		testUnmarshalErr(v28v4, bs28, h, t, "dec-map-v28-p-len")
+		testDeepEqualErr(v28v3, v28v4, t, "equal-map-v28-p-len")
+	}
+
+	for _, v := range []map[string]int8{nil, {}, {"some-string-2": 0, "some-string": 44}} {
+		// 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 = nil
+		} else {
+			v29v2 = make(map[string]int8, len(v))
+		} // reset map
+		testUnmarshalErr(v29v2, bs29, h, t, "dec-map-v29")
+		testDeepEqualErr(v29v1, v29v2, t, "equal-map-v29")
+		if v == nil {
+			v29v2 = nil
+		} else {
+			v29v2 = make(map[string]int8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v29v2), bs29, h, t, "dec-map-v29-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v29v1, v29v2, t, "equal-map-v29-noaddr")
+		if v == nil {
+			v29v2 = nil
+		} else {
+			v29v2 = make(map[string]int8, len(v))
+		} // reset map
+		testUnmarshalErr(&v29v2, bs29, h, t, "dec-map-v29-p-len")
+		testDeepEqualErr(v29v1, v29v2, t, "equal-map-v29-p-len")
+		bs29 = testMarshalErr(&v29v1, h, t, "enc-map-v29-p")
+		v29v2 = nil
+		testUnmarshalErr(&v29v2, bs29, h, t, "dec-map-v29-p-nil")
+		testDeepEqualErr(v29v1, v29v2, t, "equal-map-v29-p-nil")
+		// ...
+		if v == nil {
+			v29v2 = nil
+		} else {
+			v29v2 = make(map[string]int8, len(v))
+		} // reset map
+		var v29v3, v29v4 typMapMapStringInt8
+		v29v3 = typMapMapStringInt8(v29v1)
+		v29v4 = typMapMapStringInt8(v29v2)
+		bs29 = testMarshalErr(v29v3, h, t, "enc-map-v29-custom")
+		testUnmarshalErr(v29v4, bs29, h, t, "dec-map-v29-p-len")
+		testDeepEqualErr(v29v3, v29v4, t, "equal-map-v29-p-len")
+	}
+
+	for _, v := range []map[string]int16{nil, {}, {"some-string-2": 0, "some-string": 33}} {
+		// 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 = nil
+		} else {
+			v30v2 = make(map[string]int16, len(v))
+		} // reset map
+		testUnmarshalErr(v30v2, bs30, h, t, "dec-map-v30")
+		testDeepEqualErr(v30v1, v30v2, t, "equal-map-v30")
+		if v == nil {
+			v30v2 = nil
+		} else {
+			v30v2 = make(map[string]int16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v30v2), bs30, h, t, "dec-map-v30-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v30v1, v30v2, t, "equal-map-v30-noaddr")
+		if v == nil {
+			v30v2 = nil
+		} else {
+			v30v2 = make(map[string]int16, len(v))
+		} // reset map
+		testUnmarshalErr(&v30v2, bs30, h, t, "dec-map-v30-p-len")
+		testDeepEqualErr(v30v1, v30v2, t, "equal-map-v30-p-len")
+		bs30 = testMarshalErr(&v30v1, h, t, "enc-map-v30-p")
+		v30v2 = nil
+		testUnmarshalErr(&v30v2, bs30, h, t, "dec-map-v30-p-nil")
+		testDeepEqualErr(v30v1, v30v2, t, "equal-map-v30-p-nil")
+		// ...
+		if v == nil {
+			v30v2 = nil
+		} else {
+			v30v2 = make(map[string]int16, len(v))
+		} // reset map
+		var v30v3, v30v4 typMapMapStringInt16
+		v30v3 = typMapMapStringInt16(v30v1)
+		v30v4 = typMapMapStringInt16(v30v2)
+		bs30 = testMarshalErr(v30v3, h, t, "enc-map-v30-custom")
+		testUnmarshalErr(v30v4, bs30, h, t, "dec-map-v30-p-len")
+		testDeepEqualErr(v30v3, v30v4, t, "equal-map-v30-p-len")
+	}
+
+	for _, v := range []map[string]int32{nil, {}, {"some-string-2": 0, "some-string": 44}} {
+		// 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 = nil
+		} else {
+			v31v2 = make(map[string]int32, len(v))
+		} // reset map
+		testUnmarshalErr(v31v2, bs31, h, t, "dec-map-v31")
+		testDeepEqualErr(v31v1, v31v2, t, "equal-map-v31")
+		if v == nil {
+			v31v2 = nil
+		} else {
+			v31v2 = make(map[string]int32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v31v2), bs31, h, t, "dec-map-v31-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v31v1, v31v2, t, "equal-map-v31-noaddr")
+		if v == nil {
+			v31v2 = nil
+		} else {
+			v31v2 = make(map[string]int32, len(v))
+		} // reset map
+		testUnmarshalErr(&v31v2, bs31, h, t, "dec-map-v31-p-len")
+		testDeepEqualErr(v31v1, v31v2, t, "equal-map-v31-p-len")
+		bs31 = testMarshalErr(&v31v1, h, t, "enc-map-v31-p")
+		v31v2 = nil
+		testUnmarshalErr(&v31v2, bs31, h, t, "dec-map-v31-p-nil")
+		testDeepEqualErr(v31v1, v31v2, t, "equal-map-v31-p-nil")
+		// ...
+		if v == nil {
+			v31v2 = nil
+		} else {
+			v31v2 = make(map[string]int32, len(v))
+		} // reset map
+		var v31v3, v31v4 typMapMapStringInt32
+		v31v3 = typMapMapStringInt32(v31v1)
+		v31v4 = typMapMapStringInt32(v31v2)
+		bs31 = testMarshalErr(v31v3, h, t, "enc-map-v31-custom")
+		testUnmarshalErr(v31v4, bs31, h, t, "dec-map-v31-p-len")
+		testDeepEqualErr(v31v3, v31v4, t, "equal-map-v31-p-len")
+	}
+
+	for _, v := range []map[string]int64{nil, {}, {"some-string-2": 0, "some-string": 33}} {
+		// 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 = nil
+		} else {
+			v32v2 = make(map[string]int64, len(v))
+		} // reset map
+		testUnmarshalErr(v32v2, bs32, h, t, "dec-map-v32")
+		testDeepEqualErr(v32v1, v32v2, t, "equal-map-v32")
+		if v == nil {
+			v32v2 = nil
+		} else {
+			v32v2 = make(map[string]int64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v32v2), bs32, h, t, "dec-map-v32-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v32v1, v32v2, t, "equal-map-v32-noaddr")
+		if v == nil {
+			v32v2 = nil
+		} else {
+			v32v2 = make(map[string]int64, len(v))
+		} // reset map
+		testUnmarshalErr(&v32v2, bs32, h, t, "dec-map-v32-p-len")
+		testDeepEqualErr(v32v1, v32v2, t, "equal-map-v32-p-len")
+		bs32 = testMarshalErr(&v32v1, h, t, "enc-map-v32-p")
+		v32v2 = nil
+		testUnmarshalErr(&v32v2, bs32, h, t, "dec-map-v32-p-nil")
+		testDeepEqualErr(v32v1, v32v2, t, "equal-map-v32-p-nil")
+		// ...
+		if v == nil {
+			v32v2 = nil
+		} else {
+			v32v2 = make(map[string]int64, len(v))
+		} // reset map
+		var v32v3, v32v4 typMapMapStringInt64
+		v32v3 = typMapMapStringInt64(v32v1)
+		v32v4 = typMapMapStringInt64(v32v2)
+		bs32 = testMarshalErr(v32v3, h, t, "enc-map-v32-custom")
+		testUnmarshalErr(v32v4, bs32, h, t, "dec-map-v32-p-len")
+		testDeepEqualErr(v32v3, v32v4, t, "equal-map-v32-p-len")
+	}
+
+	for _, v := range []map[string]float32{nil, {}, {"some-string-2": 0, "some-string": 22.2}} {
+		// 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 = nil
+		} else {
+			v33v2 = make(map[string]float32, len(v))
+		} // reset map
+		testUnmarshalErr(v33v2, bs33, h, t, "dec-map-v33")
+		testDeepEqualErr(v33v1, v33v2, t, "equal-map-v33")
+		if v == nil {
+			v33v2 = nil
+		} else {
+			v33v2 = make(map[string]float32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v33v2), bs33, h, t, "dec-map-v33-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v33v1, v33v2, t, "equal-map-v33-noaddr")
+		if v == nil {
+			v33v2 = nil
+		} else {
+			v33v2 = make(map[string]float32, len(v))
+		} // reset map
+		testUnmarshalErr(&v33v2, bs33, h, t, "dec-map-v33-p-len")
+		testDeepEqualErr(v33v1, v33v2, t, "equal-map-v33-p-len")
+		bs33 = testMarshalErr(&v33v1, h, t, "enc-map-v33-p")
+		v33v2 = nil
+		testUnmarshalErr(&v33v2, bs33, h, t, "dec-map-v33-p-nil")
+		testDeepEqualErr(v33v1, v33v2, t, "equal-map-v33-p-nil")
+		// ...
+		if v == nil {
+			v33v2 = nil
+		} else {
+			v33v2 = make(map[string]float32, len(v))
+		} // reset map
+		var v33v3, v33v4 typMapMapStringFloat32
+		v33v3 = typMapMapStringFloat32(v33v1)
+		v33v4 = typMapMapStringFloat32(v33v2)
+		bs33 = testMarshalErr(v33v3, h, t, "enc-map-v33-custom")
+		testUnmarshalErr(v33v4, bs33, h, t, "dec-map-v33-p-len")
+		testDeepEqualErr(v33v3, v33v4, t, "equal-map-v33-p-len")
+	}
+
+	for _, v := range []map[string]float64{nil, {}, {"some-string-2": 0, "some-string": 11.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 = nil
+		} else {
+			v34v2 = make(map[string]float64, len(v))
+		} // reset map
+		testUnmarshalErr(v34v2, bs34, h, t, "dec-map-v34")
+		testDeepEqualErr(v34v1, v34v2, t, "equal-map-v34")
+		if v == nil {
+			v34v2 = nil
+		} else {
+			v34v2 = make(map[string]float64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v34v2), bs34, h, t, "dec-map-v34-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v34v1, v34v2, t, "equal-map-v34-noaddr")
+		if v == nil {
+			v34v2 = nil
+		} else {
+			v34v2 = make(map[string]float64, len(v))
+		} // reset map
+		testUnmarshalErr(&v34v2, bs34, h, t, "dec-map-v34-p-len")
+		testDeepEqualErr(v34v1, v34v2, t, "equal-map-v34-p-len")
+		bs34 = testMarshalErr(&v34v1, h, t, "enc-map-v34-p")
+		v34v2 = nil
+		testUnmarshalErr(&v34v2, bs34, h, t, "dec-map-v34-p-nil")
+		testDeepEqualErr(v34v1, v34v2, t, "equal-map-v34-p-nil")
+		// ...
+		if v == nil {
+			v34v2 = nil
+		} else {
+			v34v2 = make(map[string]float64, len(v))
+		} // reset map
+		var v34v3, v34v4 typMapMapStringFloat64
+		v34v3 = typMapMapStringFloat64(v34v1)
+		v34v4 = typMapMapStringFloat64(v34v2)
+		bs34 = testMarshalErr(v34v3, h, t, "enc-map-v34-custom")
+		testUnmarshalErr(v34v4, bs34, h, t, "dec-map-v34-p-len")
+		testDeepEqualErr(v34v3, v34v4, t, "equal-map-v34-p-len")
+	}
+
+	for _, v := range []map[string]bool{nil, {}, {"some-string-2": false, "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 = nil
+		} else {
+			v35v2 = make(map[string]bool, len(v))
+		} // reset map
+		testUnmarshalErr(v35v2, bs35, h, t, "dec-map-v35")
+		testDeepEqualErr(v35v1, v35v2, t, "equal-map-v35")
+		if v == nil {
+			v35v2 = nil
+		} else {
+			v35v2 = make(map[string]bool, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v35v2), bs35, h, t, "dec-map-v35-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v35v1, v35v2, t, "equal-map-v35-noaddr")
+		if v == nil {
+			v35v2 = nil
+		} else {
+			v35v2 = make(map[string]bool, len(v))
+		} // reset map
+		testUnmarshalErr(&v35v2, bs35, h, t, "dec-map-v35-p-len")
+		testDeepEqualErr(v35v1, v35v2, t, "equal-map-v35-p-len")
+		bs35 = testMarshalErr(&v35v1, h, t, "enc-map-v35-p")
+		v35v2 = nil
+		testUnmarshalErr(&v35v2, bs35, h, t, "dec-map-v35-p-nil")
+		testDeepEqualErr(v35v1, v35v2, t, "equal-map-v35-p-nil")
+		// ...
+		if v == nil {
+			v35v2 = nil
+		} else {
+			v35v2 = make(map[string]bool, len(v))
+		} // reset map
+		var v35v3, v35v4 typMapMapStringBool
+		v35v3 = typMapMapStringBool(v35v1)
+		v35v4 = typMapMapStringBool(v35v2)
+		bs35 = testMarshalErr(v35v3, h, t, "enc-map-v35-custom")
+		testUnmarshalErr(v35v4, bs35, h, t, "dec-map-v35-p-len")
+		testDeepEqualErr(v35v3, v35v4, t, "equal-map-v35-p-len")
+	}
+
+	for _, v := range []map[float32]interface{}{nil, {}, {22.2: nil, 11.1: "string-is-an-interface-2"}} {
+		// 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 = nil
+		} else {
+			v38v2 = make(map[float32]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(v38v2, bs38, h, t, "dec-map-v38")
+		testDeepEqualErr(v38v1, v38v2, t, "equal-map-v38")
+		if v == nil {
+			v38v2 = nil
+		} else {
+			v38v2 = make(map[float32]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v38v2), bs38, h, t, "dec-map-v38-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v38v1, v38v2, t, "equal-map-v38-noaddr")
+		if v == nil {
+			v38v2 = nil
+		} else {
+			v38v2 = make(map[float32]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(&v38v2, bs38, h, t, "dec-map-v38-p-len")
+		testDeepEqualErr(v38v1, v38v2, t, "equal-map-v38-p-len")
+		bs38 = testMarshalErr(&v38v1, h, t, "enc-map-v38-p")
+		v38v2 = nil
+		testUnmarshalErr(&v38v2, bs38, h, t, "dec-map-v38-p-nil")
+		testDeepEqualErr(v38v1, v38v2, t, "equal-map-v38-p-nil")
+		// ...
+		if v == nil {
+			v38v2 = nil
+		} else {
+			v38v2 = make(map[float32]interface{}, len(v))
+		} // reset map
+		var v38v3, v38v4 typMapMapFloat32Intf
+		v38v3 = typMapMapFloat32Intf(v38v1)
+		v38v4 = typMapMapFloat32Intf(v38v2)
+		bs38 = testMarshalErr(v38v3, h, t, "enc-map-v38-custom")
+		testUnmarshalErr(v38v4, bs38, h, t, "dec-map-v38-p-len")
+		testDeepEqualErr(v38v3, v38v4, t, "equal-map-v38-p-len")
+	}
+
+	for _, v := range []map[float32]string{nil, {}, {22.2: "", 11.1: "some-string-2"}} {
+		// 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 = nil
+		} else {
+			v39v2 = make(map[float32]string, len(v))
+		} // reset map
+		testUnmarshalErr(v39v2, bs39, h, t, "dec-map-v39")
+		testDeepEqualErr(v39v1, v39v2, t, "equal-map-v39")
+		if v == nil {
+			v39v2 = nil
+		} else {
+			v39v2 = make(map[float32]string, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v39v2), bs39, h, t, "dec-map-v39-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v39v1, v39v2, t, "equal-map-v39-noaddr")
+		if v == nil {
+			v39v2 = nil
+		} else {
+			v39v2 = make(map[float32]string, len(v))
+		} // reset map
+		testUnmarshalErr(&v39v2, bs39, h, t, "dec-map-v39-p-len")
+		testDeepEqualErr(v39v1, v39v2, t, "equal-map-v39-p-len")
+		bs39 = testMarshalErr(&v39v1, h, t, "enc-map-v39-p")
+		v39v2 = nil
+		testUnmarshalErr(&v39v2, bs39, h, t, "dec-map-v39-p-nil")
+		testDeepEqualErr(v39v1, v39v2, t, "equal-map-v39-p-nil")
+		// ...
+		if v == nil {
+			v39v2 = nil
+		} else {
+			v39v2 = make(map[float32]string, len(v))
+		} // reset map
+		var v39v3, v39v4 typMapMapFloat32String
+		v39v3 = typMapMapFloat32String(v39v1)
+		v39v4 = typMapMapFloat32String(v39v2)
+		bs39 = testMarshalErr(v39v3, h, t, "enc-map-v39-custom")
+		testUnmarshalErr(v39v4, bs39, h, t, "dec-map-v39-p-len")
+		testDeepEqualErr(v39v3, v39v4, t, "equal-map-v39-p-len")
+	}
+
+	for _, v := range []map[float32]uint{nil, {}, {22.2: 0, 11.1: 44}} {
+		// 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 = nil
+		} else {
+			v40v2 = make(map[float32]uint, len(v))
+		} // reset map
+		testUnmarshalErr(v40v2, bs40, h, t, "dec-map-v40")
+		testDeepEqualErr(v40v1, v40v2, t, "equal-map-v40")
+		if v == nil {
+			v40v2 = nil
+		} else {
+			v40v2 = make(map[float32]uint, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v40v2), bs40, h, t, "dec-map-v40-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v40v1, v40v2, t, "equal-map-v40-noaddr")
+		if v == nil {
+			v40v2 = nil
+		} else {
+			v40v2 = make(map[float32]uint, len(v))
+		} // reset map
+		testUnmarshalErr(&v40v2, bs40, h, t, "dec-map-v40-p-len")
+		testDeepEqualErr(v40v1, v40v2, t, "equal-map-v40-p-len")
+		bs40 = testMarshalErr(&v40v1, h, t, "enc-map-v40-p")
+		v40v2 = nil
+		testUnmarshalErr(&v40v2, bs40, h, t, "dec-map-v40-p-nil")
+		testDeepEqualErr(v40v1, v40v2, t, "equal-map-v40-p-nil")
+		// ...
+		if v == nil {
+			v40v2 = nil
+		} else {
+			v40v2 = make(map[float32]uint, len(v))
+		} // reset map
+		var v40v3, v40v4 typMapMapFloat32Uint
+		v40v3 = typMapMapFloat32Uint(v40v1)
+		v40v4 = typMapMapFloat32Uint(v40v2)
+		bs40 = testMarshalErr(v40v3, h, t, "enc-map-v40-custom")
+		testUnmarshalErr(v40v4, bs40, h, t, "dec-map-v40-p-len")
+		testDeepEqualErr(v40v3, v40v4, t, "equal-map-v40-p-len")
+	}
+
+	for _, v := range []map[float32]uint8{nil, {}, {22.2: 0, 11.1: 33}} {
+		// 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 = nil
+		} else {
+			v41v2 = make(map[float32]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(v41v2, bs41, h, t, "dec-map-v41")
+		testDeepEqualErr(v41v1, v41v2, t, "equal-map-v41")
+		if v == nil {
+			v41v2 = nil
+		} else {
+			v41v2 = make(map[float32]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v41v2), bs41, h, t, "dec-map-v41-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v41v1, v41v2, t, "equal-map-v41-noaddr")
+		if v == nil {
+			v41v2 = nil
+		} else {
+			v41v2 = make(map[float32]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(&v41v2, bs41, h, t, "dec-map-v41-p-len")
+		testDeepEqualErr(v41v1, v41v2, t, "equal-map-v41-p-len")
+		bs41 = testMarshalErr(&v41v1, h, t, "enc-map-v41-p")
+		v41v2 = nil
+		testUnmarshalErr(&v41v2, bs41, h, t, "dec-map-v41-p-nil")
+		testDeepEqualErr(v41v1, v41v2, t, "equal-map-v41-p-nil")
+		// ...
+		if v == nil {
+			v41v2 = nil
+		} else {
+			v41v2 = make(map[float32]uint8, len(v))
+		} // reset map
+		var v41v3, v41v4 typMapMapFloat32Uint8
+		v41v3 = typMapMapFloat32Uint8(v41v1)
+		v41v4 = typMapMapFloat32Uint8(v41v2)
+		bs41 = testMarshalErr(v41v3, h, t, "enc-map-v41-custom")
+		testUnmarshalErr(v41v4, bs41, h, t, "dec-map-v41-p-len")
+		testDeepEqualErr(v41v3, v41v4, t, "equal-map-v41-p-len")
+	}
+
+	for _, v := range []map[float32]uint16{nil, {}, {22.2: 0, 11.1: 44}} {
+		// 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 = nil
+		} else {
+			v42v2 = make(map[float32]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(v42v2, bs42, h, t, "dec-map-v42")
+		testDeepEqualErr(v42v1, v42v2, t, "equal-map-v42")
+		if v == nil {
+			v42v2 = nil
+		} else {
+			v42v2 = make(map[float32]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v42v2), bs42, h, t, "dec-map-v42-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v42v1, v42v2, t, "equal-map-v42-noaddr")
+		if v == nil {
+			v42v2 = nil
+		} else {
+			v42v2 = make(map[float32]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(&v42v2, bs42, h, t, "dec-map-v42-p-len")
+		testDeepEqualErr(v42v1, v42v2, t, "equal-map-v42-p-len")
+		bs42 = testMarshalErr(&v42v1, h, t, "enc-map-v42-p")
+		v42v2 = nil
+		testUnmarshalErr(&v42v2, bs42, h, t, "dec-map-v42-p-nil")
+		testDeepEqualErr(v42v1, v42v2, t, "equal-map-v42-p-nil")
+		// ...
+		if v == nil {
+			v42v2 = nil
+		} else {
+			v42v2 = make(map[float32]uint16, len(v))
+		} // reset map
+		var v42v3, v42v4 typMapMapFloat32Uint16
+		v42v3 = typMapMapFloat32Uint16(v42v1)
+		v42v4 = typMapMapFloat32Uint16(v42v2)
+		bs42 = testMarshalErr(v42v3, h, t, "enc-map-v42-custom")
+		testUnmarshalErr(v42v4, bs42, h, t, "dec-map-v42-p-len")
+		testDeepEqualErr(v42v3, v42v4, t, "equal-map-v42-p-len")
+	}
+
+	for _, v := range []map[float32]uint32{nil, {}, {22.2: 0, 11.1: 33}} {
+		// 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 = nil
+		} else {
+			v43v2 = make(map[float32]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(v43v2, bs43, h, t, "dec-map-v43")
+		testDeepEqualErr(v43v1, v43v2, t, "equal-map-v43")
+		if v == nil {
+			v43v2 = nil
+		} else {
+			v43v2 = make(map[float32]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v43v2), bs43, h, t, "dec-map-v43-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v43v1, v43v2, t, "equal-map-v43-noaddr")
+		if v == nil {
+			v43v2 = nil
+		} else {
+			v43v2 = make(map[float32]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(&v43v2, bs43, h, t, "dec-map-v43-p-len")
+		testDeepEqualErr(v43v1, v43v2, t, "equal-map-v43-p-len")
+		bs43 = testMarshalErr(&v43v1, h, t, "enc-map-v43-p")
+		v43v2 = nil
+		testUnmarshalErr(&v43v2, bs43, h, t, "dec-map-v43-p-nil")
+		testDeepEqualErr(v43v1, v43v2, t, "equal-map-v43-p-nil")
+		// ...
+		if v == nil {
+			v43v2 = nil
+		} else {
+			v43v2 = make(map[float32]uint32, len(v))
+		} // reset map
+		var v43v3, v43v4 typMapMapFloat32Uint32
+		v43v3 = typMapMapFloat32Uint32(v43v1)
+		v43v4 = typMapMapFloat32Uint32(v43v2)
+		bs43 = testMarshalErr(v43v3, h, t, "enc-map-v43-custom")
+		testUnmarshalErr(v43v4, bs43, h, t, "dec-map-v43-p-len")
+		testDeepEqualErr(v43v3, v43v4, t, "equal-map-v43-p-len")
+	}
+
+	for _, v := range []map[float32]uint64{nil, {}, {22.2: 0, 11.1: 44}} {
+		// 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 = nil
+		} else {
+			v44v2 = make(map[float32]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(v44v2, bs44, h, t, "dec-map-v44")
+		testDeepEqualErr(v44v1, v44v2, t, "equal-map-v44")
+		if v == nil {
+			v44v2 = nil
+		} else {
+			v44v2 = make(map[float32]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v44v2), bs44, h, t, "dec-map-v44-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v44v1, v44v2, t, "equal-map-v44-noaddr")
+		if v == nil {
+			v44v2 = nil
+		} else {
+			v44v2 = make(map[float32]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(&v44v2, bs44, h, t, "dec-map-v44-p-len")
+		testDeepEqualErr(v44v1, v44v2, t, "equal-map-v44-p-len")
+		bs44 = testMarshalErr(&v44v1, h, t, "enc-map-v44-p")
+		v44v2 = nil
+		testUnmarshalErr(&v44v2, bs44, h, t, "dec-map-v44-p-nil")
+		testDeepEqualErr(v44v1, v44v2, t, "equal-map-v44-p-nil")
+		// ...
+		if v == nil {
+			v44v2 = nil
+		} else {
+			v44v2 = make(map[float32]uint64, len(v))
+		} // reset map
+		var v44v3, v44v4 typMapMapFloat32Uint64
+		v44v3 = typMapMapFloat32Uint64(v44v1)
+		v44v4 = typMapMapFloat32Uint64(v44v2)
+		bs44 = testMarshalErr(v44v3, h, t, "enc-map-v44-custom")
+		testUnmarshalErr(v44v4, bs44, h, t, "dec-map-v44-p-len")
+		testDeepEqualErr(v44v3, v44v4, t, "equal-map-v44-p-len")
+	}
+
+	for _, v := range []map[float32]uintptr{nil, {}, {22.2: 0, 11.1: 33}} {
+		// 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 = nil
+		} else {
+			v45v2 = make(map[float32]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(v45v2, bs45, h, t, "dec-map-v45")
+		testDeepEqualErr(v45v1, v45v2, t, "equal-map-v45")
+		if v == nil {
+			v45v2 = nil
+		} else {
+			v45v2 = make(map[float32]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v45v2), bs45, h, t, "dec-map-v45-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v45v1, v45v2, t, "equal-map-v45-noaddr")
+		if v == nil {
+			v45v2 = nil
+		} else {
+			v45v2 = make(map[float32]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(&v45v2, bs45, h, t, "dec-map-v45-p-len")
+		testDeepEqualErr(v45v1, v45v2, t, "equal-map-v45-p-len")
+		bs45 = testMarshalErr(&v45v1, h, t, "enc-map-v45-p")
+		v45v2 = nil
+		testUnmarshalErr(&v45v2, bs45, h, t, "dec-map-v45-p-nil")
+		testDeepEqualErr(v45v1, v45v2, t, "equal-map-v45-p-nil")
+		// ...
+		if v == nil {
+			v45v2 = nil
+		} else {
+			v45v2 = make(map[float32]uintptr, len(v))
+		} // reset map
+		var v45v3, v45v4 typMapMapFloat32Uintptr
+		v45v3 = typMapMapFloat32Uintptr(v45v1)
+		v45v4 = typMapMapFloat32Uintptr(v45v2)
+		bs45 = testMarshalErr(v45v3, h, t, "enc-map-v45-custom")
+		testUnmarshalErr(v45v4, bs45, h, t, "dec-map-v45-p-len")
+		testDeepEqualErr(v45v3, v45v4, t, "equal-map-v45-p-len")
+	}
+
+	for _, v := range []map[float32]int{nil, {}, {22.2: 0, 11.1: 44}} {
+		// 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 = nil
+		} else {
+			v46v2 = make(map[float32]int, len(v))
+		} // reset map
+		testUnmarshalErr(v46v2, bs46, h, t, "dec-map-v46")
+		testDeepEqualErr(v46v1, v46v2, t, "equal-map-v46")
+		if v == nil {
+			v46v2 = nil
+		} else {
+			v46v2 = make(map[float32]int, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v46v2), bs46, h, t, "dec-map-v46-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v46v1, v46v2, t, "equal-map-v46-noaddr")
+		if v == nil {
+			v46v2 = nil
+		} else {
+			v46v2 = make(map[float32]int, len(v))
+		} // reset map
+		testUnmarshalErr(&v46v2, bs46, h, t, "dec-map-v46-p-len")
+		testDeepEqualErr(v46v1, v46v2, t, "equal-map-v46-p-len")
+		bs46 = testMarshalErr(&v46v1, h, t, "enc-map-v46-p")
+		v46v2 = nil
+		testUnmarshalErr(&v46v2, bs46, h, t, "dec-map-v46-p-nil")
+		testDeepEqualErr(v46v1, v46v2, t, "equal-map-v46-p-nil")
+		// ...
+		if v == nil {
+			v46v2 = nil
+		} else {
+			v46v2 = make(map[float32]int, len(v))
+		} // reset map
+		var v46v3, v46v4 typMapMapFloat32Int
+		v46v3 = typMapMapFloat32Int(v46v1)
+		v46v4 = typMapMapFloat32Int(v46v2)
+		bs46 = testMarshalErr(v46v3, h, t, "enc-map-v46-custom")
+		testUnmarshalErr(v46v4, bs46, h, t, "dec-map-v46-p-len")
+		testDeepEqualErr(v46v3, v46v4, t, "equal-map-v46-p-len")
+	}
+
+	for _, v := range []map[float32]int8{nil, {}, {22.2: 0, 11.1: 33}} {
+		// 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 = nil
+		} else {
+			v47v2 = make(map[float32]int8, len(v))
+		} // reset map
+		testUnmarshalErr(v47v2, bs47, h, t, "dec-map-v47")
+		testDeepEqualErr(v47v1, v47v2, t, "equal-map-v47")
+		if v == nil {
+			v47v2 = nil
+		} else {
+			v47v2 = make(map[float32]int8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v47v2), bs47, h, t, "dec-map-v47-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v47v1, v47v2, t, "equal-map-v47-noaddr")
+		if v == nil {
+			v47v2 = nil
+		} else {
+			v47v2 = make(map[float32]int8, len(v))
+		} // reset map
+		testUnmarshalErr(&v47v2, bs47, h, t, "dec-map-v47-p-len")
+		testDeepEqualErr(v47v1, v47v2, t, "equal-map-v47-p-len")
+		bs47 = testMarshalErr(&v47v1, h, t, "enc-map-v47-p")
+		v47v2 = nil
+		testUnmarshalErr(&v47v2, bs47, h, t, "dec-map-v47-p-nil")
+		testDeepEqualErr(v47v1, v47v2, t, "equal-map-v47-p-nil")
+		// ...
+		if v == nil {
+			v47v2 = nil
+		} else {
+			v47v2 = make(map[float32]int8, len(v))
+		} // reset map
+		var v47v3, v47v4 typMapMapFloat32Int8
+		v47v3 = typMapMapFloat32Int8(v47v1)
+		v47v4 = typMapMapFloat32Int8(v47v2)
+		bs47 = testMarshalErr(v47v3, h, t, "enc-map-v47-custom")
+		testUnmarshalErr(v47v4, bs47, h, t, "dec-map-v47-p-len")
+		testDeepEqualErr(v47v3, v47v4, t, "equal-map-v47-p-len")
+	}
+
+	for _, v := range []map[float32]int16{nil, {}, {22.2: 0, 11.1: 44}} {
+		// 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 = nil
+		} else {
+			v48v2 = make(map[float32]int16, len(v))
+		} // reset map
+		testUnmarshalErr(v48v2, bs48, h, t, "dec-map-v48")
+		testDeepEqualErr(v48v1, v48v2, t, "equal-map-v48")
+		if v == nil {
+			v48v2 = nil
+		} else {
+			v48v2 = make(map[float32]int16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v48v2), bs48, h, t, "dec-map-v48-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v48v1, v48v2, t, "equal-map-v48-noaddr")
+		if v == nil {
+			v48v2 = nil
+		} else {
+			v48v2 = make(map[float32]int16, len(v))
+		} // reset map
+		testUnmarshalErr(&v48v2, bs48, h, t, "dec-map-v48-p-len")
+		testDeepEqualErr(v48v1, v48v2, t, "equal-map-v48-p-len")
+		bs48 = testMarshalErr(&v48v1, h, t, "enc-map-v48-p")
+		v48v2 = nil
+		testUnmarshalErr(&v48v2, bs48, h, t, "dec-map-v48-p-nil")
+		testDeepEqualErr(v48v1, v48v2, t, "equal-map-v48-p-nil")
+		// ...
+		if v == nil {
+			v48v2 = nil
+		} else {
+			v48v2 = make(map[float32]int16, len(v))
+		} // reset map
+		var v48v3, v48v4 typMapMapFloat32Int16
+		v48v3 = typMapMapFloat32Int16(v48v1)
+		v48v4 = typMapMapFloat32Int16(v48v2)
+		bs48 = testMarshalErr(v48v3, h, t, "enc-map-v48-custom")
+		testUnmarshalErr(v48v4, bs48, h, t, "dec-map-v48-p-len")
+		testDeepEqualErr(v48v3, v48v4, t, "equal-map-v48-p-len")
+	}
+
+	for _, v := range []map[float32]int32{nil, {}, {22.2: 0, 11.1: 33}} {
+		// 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 = nil
+		} else {
+			v49v2 = make(map[float32]int32, len(v))
+		} // reset map
+		testUnmarshalErr(v49v2, bs49, h, t, "dec-map-v49")
+		testDeepEqualErr(v49v1, v49v2, t, "equal-map-v49")
+		if v == nil {
+			v49v2 = nil
+		} else {
+			v49v2 = make(map[float32]int32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v49v2), bs49, h, t, "dec-map-v49-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v49v1, v49v2, t, "equal-map-v49-noaddr")
+		if v == nil {
+			v49v2 = nil
+		} else {
+			v49v2 = make(map[float32]int32, len(v))
+		} // reset map
+		testUnmarshalErr(&v49v2, bs49, h, t, "dec-map-v49-p-len")
+		testDeepEqualErr(v49v1, v49v2, t, "equal-map-v49-p-len")
+		bs49 = testMarshalErr(&v49v1, h, t, "enc-map-v49-p")
+		v49v2 = nil
+		testUnmarshalErr(&v49v2, bs49, h, t, "dec-map-v49-p-nil")
+		testDeepEqualErr(v49v1, v49v2, t, "equal-map-v49-p-nil")
+		// ...
+		if v == nil {
+			v49v2 = nil
+		} else {
+			v49v2 = make(map[float32]int32, len(v))
+		} // reset map
+		var v49v3, v49v4 typMapMapFloat32Int32
+		v49v3 = typMapMapFloat32Int32(v49v1)
+		v49v4 = typMapMapFloat32Int32(v49v2)
+		bs49 = testMarshalErr(v49v3, h, t, "enc-map-v49-custom")
+		testUnmarshalErr(v49v4, bs49, h, t, "dec-map-v49-p-len")
+		testDeepEqualErr(v49v3, v49v4, t, "equal-map-v49-p-len")
+	}
+
+	for _, v := range []map[float32]int64{nil, {}, {22.2: 0, 11.1: 44}} {
+		// 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 = nil
+		} else {
+			v50v2 = make(map[float32]int64, len(v))
+		} // reset map
+		testUnmarshalErr(v50v2, bs50, h, t, "dec-map-v50")
+		testDeepEqualErr(v50v1, v50v2, t, "equal-map-v50")
+		if v == nil {
+			v50v2 = nil
+		} else {
+			v50v2 = make(map[float32]int64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v50v2), bs50, h, t, "dec-map-v50-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v50v1, v50v2, t, "equal-map-v50-noaddr")
+		if v == nil {
+			v50v2 = nil
+		} else {
+			v50v2 = make(map[float32]int64, len(v))
+		} // reset map
+		testUnmarshalErr(&v50v2, bs50, h, t, "dec-map-v50-p-len")
+		testDeepEqualErr(v50v1, v50v2, t, "equal-map-v50-p-len")
+		bs50 = testMarshalErr(&v50v1, h, t, "enc-map-v50-p")
+		v50v2 = nil
+		testUnmarshalErr(&v50v2, bs50, h, t, "dec-map-v50-p-nil")
+		testDeepEqualErr(v50v1, v50v2, t, "equal-map-v50-p-nil")
+		// ...
+		if v == nil {
+			v50v2 = nil
+		} else {
+			v50v2 = make(map[float32]int64, len(v))
+		} // reset map
+		var v50v3, v50v4 typMapMapFloat32Int64
+		v50v3 = typMapMapFloat32Int64(v50v1)
+		v50v4 = typMapMapFloat32Int64(v50v2)
+		bs50 = testMarshalErr(v50v3, h, t, "enc-map-v50-custom")
+		testUnmarshalErr(v50v4, bs50, h, t, "dec-map-v50-p-len")
+		testDeepEqualErr(v50v3, v50v4, t, "equal-map-v50-p-len")
+	}
+
+	for _, v := range []map[float32]float32{nil, {}, {22.2: 0, 11.1: 22.2}} {
+		// 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 = nil
+		} else {
+			v51v2 = make(map[float32]float32, len(v))
+		} // reset map
+		testUnmarshalErr(v51v2, bs51, h, t, "dec-map-v51")
+		testDeepEqualErr(v51v1, v51v2, t, "equal-map-v51")
+		if v == nil {
+			v51v2 = nil
+		} else {
+			v51v2 = make(map[float32]float32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v51v2), bs51, h, t, "dec-map-v51-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v51v1, v51v2, t, "equal-map-v51-noaddr")
+		if v == nil {
+			v51v2 = nil
+		} else {
+			v51v2 = make(map[float32]float32, len(v))
+		} // reset map
+		testUnmarshalErr(&v51v2, bs51, h, t, "dec-map-v51-p-len")
+		testDeepEqualErr(v51v1, v51v2, t, "equal-map-v51-p-len")
+		bs51 = testMarshalErr(&v51v1, h, t, "enc-map-v51-p")
+		v51v2 = nil
+		testUnmarshalErr(&v51v2, bs51, h, t, "dec-map-v51-p-nil")
+		testDeepEqualErr(v51v1, v51v2, t, "equal-map-v51-p-nil")
+		// ...
+		if v == nil {
+			v51v2 = nil
+		} else {
+			v51v2 = make(map[float32]float32, len(v))
+		} // reset map
+		var v51v3, v51v4 typMapMapFloat32Float32
+		v51v3 = typMapMapFloat32Float32(v51v1)
+		v51v4 = typMapMapFloat32Float32(v51v2)
+		bs51 = testMarshalErr(v51v3, h, t, "enc-map-v51-custom")
+		testUnmarshalErr(v51v4, bs51, h, t, "dec-map-v51-p-len")
+		testDeepEqualErr(v51v3, v51v4, t, "equal-map-v51-p-len")
+	}
+
+	for _, v := range []map[float32]float64{nil, {}, {11.1: 0, 22.2: 11.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 = nil
+		} else {
+			v52v2 = make(map[float32]float64, len(v))
+		} // reset map
+		testUnmarshalErr(v52v2, bs52, h, t, "dec-map-v52")
+		testDeepEqualErr(v52v1, v52v2, t, "equal-map-v52")
+		if v == nil {
+			v52v2 = nil
+		} else {
+			v52v2 = make(map[float32]float64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v52v2), bs52, h, t, "dec-map-v52-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v52v1, v52v2, t, "equal-map-v52-noaddr")
+		if v == nil {
+			v52v2 = nil
+		} else {
+			v52v2 = make(map[float32]float64, len(v))
+		} // reset map
+		testUnmarshalErr(&v52v2, bs52, h, t, "dec-map-v52-p-len")
+		testDeepEqualErr(v52v1, v52v2, t, "equal-map-v52-p-len")
+		bs52 = testMarshalErr(&v52v1, h, t, "enc-map-v52-p")
+		v52v2 = nil
+		testUnmarshalErr(&v52v2, bs52, h, t, "dec-map-v52-p-nil")
+		testDeepEqualErr(v52v1, v52v2, t, "equal-map-v52-p-nil")
+		// ...
+		if v == nil {
+			v52v2 = nil
+		} else {
+			v52v2 = make(map[float32]float64, len(v))
+		} // reset map
+		var v52v3, v52v4 typMapMapFloat32Float64
+		v52v3 = typMapMapFloat32Float64(v52v1)
+		v52v4 = typMapMapFloat32Float64(v52v2)
+		bs52 = testMarshalErr(v52v3, h, t, "enc-map-v52-custom")
+		testUnmarshalErr(v52v4, bs52, h, t, "dec-map-v52-p-len")
+		testDeepEqualErr(v52v3, v52v4, t, "equal-map-v52-p-len")
+	}
+
+	for _, v := range []map[float32]bool{nil, {}, {22.2: false, 11.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 = nil
+		} else {
+			v53v2 = make(map[float32]bool, len(v))
+		} // reset map
+		testUnmarshalErr(v53v2, bs53, h, t, "dec-map-v53")
+		testDeepEqualErr(v53v1, v53v2, t, "equal-map-v53")
+		if v == nil {
+			v53v2 = nil
+		} else {
+			v53v2 = make(map[float32]bool, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v53v2), bs53, h, t, "dec-map-v53-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v53v1, v53v2, t, "equal-map-v53-noaddr")
+		if v == nil {
+			v53v2 = nil
+		} else {
+			v53v2 = make(map[float32]bool, len(v))
+		} // reset map
+		testUnmarshalErr(&v53v2, bs53, h, t, "dec-map-v53-p-len")
+		testDeepEqualErr(v53v1, v53v2, t, "equal-map-v53-p-len")
+		bs53 = testMarshalErr(&v53v1, h, t, "enc-map-v53-p")
+		v53v2 = nil
+		testUnmarshalErr(&v53v2, bs53, h, t, "dec-map-v53-p-nil")
+		testDeepEqualErr(v53v1, v53v2, t, "equal-map-v53-p-nil")
+		// ...
+		if v == nil {
+			v53v2 = nil
+		} else {
+			v53v2 = make(map[float32]bool, len(v))
+		} // reset map
+		var v53v3, v53v4 typMapMapFloat32Bool
+		v53v3 = typMapMapFloat32Bool(v53v1)
+		v53v4 = typMapMapFloat32Bool(v53v2)
+		bs53 = testMarshalErr(v53v3, h, t, "enc-map-v53-custom")
+		testUnmarshalErr(v53v4, bs53, h, t, "dec-map-v53-p-len")
+		testDeepEqualErr(v53v3, v53v4, t, "equal-map-v53-p-len")
+	}
+
+	for _, v := range []map[float64]interface{}{nil, {}, {22.2: nil, 11.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 = nil
+		} else {
+			v56v2 = make(map[float64]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(v56v2, bs56, h, t, "dec-map-v56")
+		testDeepEqualErr(v56v1, v56v2, t, "equal-map-v56")
+		if v == nil {
+			v56v2 = nil
+		} else {
+			v56v2 = make(map[float64]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v56v2), bs56, h, t, "dec-map-v56-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v56v1, v56v2, t, "equal-map-v56-noaddr")
+		if v == nil {
+			v56v2 = nil
+		} else {
+			v56v2 = make(map[float64]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(&v56v2, bs56, h, t, "dec-map-v56-p-len")
+		testDeepEqualErr(v56v1, v56v2, t, "equal-map-v56-p-len")
+		bs56 = testMarshalErr(&v56v1, h, t, "enc-map-v56-p")
+		v56v2 = nil
+		testUnmarshalErr(&v56v2, bs56, h, t, "dec-map-v56-p-nil")
+		testDeepEqualErr(v56v1, v56v2, t, "equal-map-v56-p-nil")
+		// ...
+		if v == nil {
+			v56v2 = nil
+		} else {
+			v56v2 = make(map[float64]interface{}, len(v))
+		} // reset map
+		var v56v3, v56v4 typMapMapFloat64Intf
+		v56v3 = typMapMapFloat64Intf(v56v1)
+		v56v4 = typMapMapFloat64Intf(v56v2)
+		bs56 = testMarshalErr(v56v3, h, t, "enc-map-v56-custom")
+		testUnmarshalErr(v56v4, bs56, h, t, "dec-map-v56-p-len")
+		testDeepEqualErr(v56v3, v56v4, t, "equal-map-v56-p-len")
+	}
+
+	for _, v := range []map[float64]string{nil, {}, {22.2: "", 11.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 = nil
+		} else {
+			v57v2 = make(map[float64]string, len(v))
+		} // reset map
+		testUnmarshalErr(v57v2, bs57, h, t, "dec-map-v57")
+		testDeepEqualErr(v57v1, v57v2, t, "equal-map-v57")
+		if v == nil {
+			v57v2 = nil
+		} else {
+			v57v2 = make(map[float64]string, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v57v2), bs57, h, t, "dec-map-v57-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v57v1, v57v2, t, "equal-map-v57-noaddr")
+		if v == nil {
+			v57v2 = nil
+		} else {
+			v57v2 = make(map[float64]string, len(v))
+		} // reset map
+		testUnmarshalErr(&v57v2, bs57, h, t, "dec-map-v57-p-len")
+		testDeepEqualErr(v57v1, v57v2, t, "equal-map-v57-p-len")
+		bs57 = testMarshalErr(&v57v1, h, t, "enc-map-v57-p")
+		v57v2 = nil
+		testUnmarshalErr(&v57v2, bs57, h, t, "dec-map-v57-p-nil")
+		testDeepEqualErr(v57v1, v57v2, t, "equal-map-v57-p-nil")
+		// ...
+		if v == nil {
+			v57v2 = nil
+		} else {
+			v57v2 = make(map[float64]string, len(v))
+		} // reset map
+		var v57v3, v57v4 typMapMapFloat64String
+		v57v3 = typMapMapFloat64String(v57v1)
+		v57v4 = typMapMapFloat64String(v57v2)
+		bs57 = testMarshalErr(v57v3, h, t, "enc-map-v57-custom")
+		testUnmarshalErr(v57v4, bs57, h, t, "dec-map-v57-p-len")
+		testDeepEqualErr(v57v3, v57v4, t, "equal-map-v57-p-len")
+	}
+
+	for _, v := range []map[float64]uint{nil, {}, {22.2: 0, 11.1: 33}} {
+		// 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 = nil
+		} else {
+			v58v2 = make(map[float64]uint, len(v))
+		} // reset map
+		testUnmarshalErr(v58v2, bs58, h, t, "dec-map-v58")
+		testDeepEqualErr(v58v1, v58v2, t, "equal-map-v58")
+		if v == nil {
+			v58v2 = nil
+		} else {
+			v58v2 = make(map[float64]uint, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v58v2), bs58, h, t, "dec-map-v58-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v58v1, v58v2, t, "equal-map-v58-noaddr")
+		if v == nil {
+			v58v2 = nil
+		} else {
+			v58v2 = make(map[float64]uint, len(v))
+		} // reset map
+		testUnmarshalErr(&v58v2, bs58, h, t, "dec-map-v58-p-len")
+		testDeepEqualErr(v58v1, v58v2, t, "equal-map-v58-p-len")
+		bs58 = testMarshalErr(&v58v1, h, t, "enc-map-v58-p")
+		v58v2 = nil
+		testUnmarshalErr(&v58v2, bs58, h, t, "dec-map-v58-p-nil")
+		testDeepEqualErr(v58v1, v58v2, t, "equal-map-v58-p-nil")
+		// ...
+		if v == nil {
+			v58v2 = nil
+		} else {
+			v58v2 = make(map[float64]uint, len(v))
+		} // reset map
+		var v58v3, v58v4 typMapMapFloat64Uint
+		v58v3 = typMapMapFloat64Uint(v58v1)
+		v58v4 = typMapMapFloat64Uint(v58v2)
+		bs58 = testMarshalErr(v58v3, h, t, "enc-map-v58-custom")
+		testUnmarshalErr(v58v4, bs58, h, t, "dec-map-v58-p-len")
+		testDeepEqualErr(v58v3, v58v4, t, "equal-map-v58-p-len")
+	}
+
+	for _, v := range []map[float64]uint8{nil, {}, {22.2: 0, 11.1: 44}} {
+		// 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 = nil
+		} else {
+			v59v2 = make(map[float64]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(v59v2, bs59, h, t, "dec-map-v59")
+		testDeepEqualErr(v59v1, v59v2, t, "equal-map-v59")
+		if v == nil {
+			v59v2 = nil
+		} else {
+			v59v2 = make(map[float64]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v59v2), bs59, h, t, "dec-map-v59-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v59v1, v59v2, t, "equal-map-v59-noaddr")
+		if v == nil {
+			v59v2 = nil
+		} else {
+			v59v2 = make(map[float64]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(&v59v2, bs59, h, t, "dec-map-v59-p-len")
+		testDeepEqualErr(v59v1, v59v2, t, "equal-map-v59-p-len")
+		bs59 = testMarshalErr(&v59v1, h, t, "enc-map-v59-p")
+		v59v2 = nil
+		testUnmarshalErr(&v59v2, bs59, h, t, "dec-map-v59-p-nil")
+		testDeepEqualErr(v59v1, v59v2, t, "equal-map-v59-p-nil")
+		// ...
+		if v == nil {
+			v59v2 = nil
+		} else {
+			v59v2 = make(map[float64]uint8, len(v))
+		} // reset map
+		var v59v3, v59v4 typMapMapFloat64Uint8
+		v59v3 = typMapMapFloat64Uint8(v59v1)
+		v59v4 = typMapMapFloat64Uint8(v59v2)
+		bs59 = testMarshalErr(v59v3, h, t, "enc-map-v59-custom")
+		testUnmarshalErr(v59v4, bs59, h, t, "dec-map-v59-p-len")
+		testDeepEqualErr(v59v3, v59v4, t, "equal-map-v59-p-len")
+	}
+
+	for _, v := range []map[float64]uint16{nil, {}, {22.2: 0, 11.1: 33}} {
+		// 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 = nil
+		} else {
+			v60v2 = make(map[float64]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(v60v2, bs60, h, t, "dec-map-v60")
+		testDeepEqualErr(v60v1, v60v2, t, "equal-map-v60")
+		if v == nil {
+			v60v2 = nil
+		} else {
+			v60v2 = make(map[float64]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v60v2), bs60, h, t, "dec-map-v60-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v60v1, v60v2, t, "equal-map-v60-noaddr")
+		if v == nil {
+			v60v2 = nil
+		} else {
+			v60v2 = make(map[float64]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(&v60v2, bs60, h, t, "dec-map-v60-p-len")
+		testDeepEqualErr(v60v1, v60v2, t, "equal-map-v60-p-len")
+		bs60 = testMarshalErr(&v60v1, h, t, "enc-map-v60-p")
+		v60v2 = nil
+		testUnmarshalErr(&v60v2, bs60, h, t, "dec-map-v60-p-nil")
+		testDeepEqualErr(v60v1, v60v2, t, "equal-map-v60-p-nil")
+		// ...
+		if v == nil {
+			v60v2 = nil
+		} else {
+			v60v2 = make(map[float64]uint16, len(v))
+		} // reset map
+		var v60v3, v60v4 typMapMapFloat64Uint16
+		v60v3 = typMapMapFloat64Uint16(v60v1)
+		v60v4 = typMapMapFloat64Uint16(v60v2)
+		bs60 = testMarshalErr(v60v3, h, t, "enc-map-v60-custom")
+		testUnmarshalErr(v60v4, bs60, h, t, "dec-map-v60-p-len")
+		testDeepEqualErr(v60v3, v60v4, t, "equal-map-v60-p-len")
+	}
+
+	for _, v := range []map[float64]uint32{nil, {}, {22.2: 0, 11.1: 44}} {
+		// 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 = nil
+		} else {
+			v61v2 = make(map[float64]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(v61v2, bs61, h, t, "dec-map-v61")
+		testDeepEqualErr(v61v1, v61v2, t, "equal-map-v61")
+		if v == nil {
+			v61v2 = nil
+		} else {
+			v61v2 = make(map[float64]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v61v2), bs61, h, t, "dec-map-v61-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v61v1, v61v2, t, "equal-map-v61-noaddr")
+		if v == nil {
+			v61v2 = nil
+		} else {
+			v61v2 = make(map[float64]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(&v61v2, bs61, h, t, "dec-map-v61-p-len")
+		testDeepEqualErr(v61v1, v61v2, t, "equal-map-v61-p-len")
+		bs61 = testMarshalErr(&v61v1, h, t, "enc-map-v61-p")
+		v61v2 = nil
+		testUnmarshalErr(&v61v2, bs61, h, t, "dec-map-v61-p-nil")
+		testDeepEqualErr(v61v1, v61v2, t, "equal-map-v61-p-nil")
+		// ...
+		if v == nil {
+			v61v2 = nil
+		} else {
+			v61v2 = make(map[float64]uint32, len(v))
+		} // reset map
+		var v61v3, v61v4 typMapMapFloat64Uint32
+		v61v3 = typMapMapFloat64Uint32(v61v1)
+		v61v4 = typMapMapFloat64Uint32(v61v2)
+		bs61 = testMarshalErr(v61v3, h, t, "enc-map-v61-custom")
+		testUnmarshalErr(v61v4, bs61, h, t, "dec-map-v61-p-len")
+		testDeepEqualErr(v61v3, v61v4, t, "equal-map-v61-p-len")
+	}
+
+	for _, v := range []map[float64]uint64{nil, {}, {22.2: 0, 11.1: 33}} {
+		// 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 = nil
+		} else {
+			v62v2 = make(map[float64]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(v62v2, bs62, h, t, "dec-map-v62")
+		testDeepEqualErr(v62v1, v62v2, t, "equal-map-v62")
+		if v == nil {
+			v62v2 = nil
+		} else {
+			v62v2 = make(map[float64]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v62v2), bs62, h, t, "dec-map-v62-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v62v1, v62v2, t, "equal-map-v62-noaddr")
+		if v == nil {
+			v62v2 = nil
+		} else {
+			v62v2 = make(map[float64]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(&v62v2, bs62, h, t, "dec-map-v62-p-len")
+		testDeepEqualErr(v62v1, v62v2, t, "equal-map-v62-p-len")
+		bs62 = testMarshalErr(&v62v1, h, t, "enc-map-v62-p")
+		v62v2 = nil
+		testUnmarshalErr(&v62v2, bs62, h, t, "dec-map-v62-p-nil")
+		testDeepEqualErr(v62v1, v62v2, t, "equal-map-v62-p-nil")
+		// ...
+		if v == nil {
+			v62v2 = nil
+		} else {
+			v62v2 = make(map[float64]uint64, len(v))
+		} // reset map
+		var v62v3, v62v4 typMapMapFloat64Uint64
+		v62v3 = typMapMapFloat64Uint64(v62v1)
+		v62v4 = typMapMapFloat64Uint64(v62v2)
+		bs62 = testMarshalErr(v62v3, h, t, "enc-map-v62-custom")
+		testUnmarshalErr(v62v4, bs62, h, t, "dec-map-v62-p-len")
+		testDeepEqualErr(v62v3, v62v4, t, "equal-map-v62-p-len")
+	}
+
+	for _, v := range []map[float64]uintptr{nil, {}, {22.2: 0, 11.1: 44}} {
+		// 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 = nil
+		} else {
+			v63v2 = make(map[float64]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(v63v2, bs63, h, t, "dec-map-v63")
+		testDeepEqualErr(v63v1, v63v2, t, "equal-map-v63")
+		if v == nil {
+			v63v2 = nil
+		} else {
+			v63v2 = make(map[float64]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v63v2), bs63, h, t, "dec-map-v63-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v63v1, v63v2, t, "equal-map-v63-noaddr")
+		if v == nil {
+			v63v2 = nil
+		} else {
+			v63v2 = make(map[float64]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(&v63v2, bs63, h, t, "dec-map-v63-p-len")
+		testDeepEqualErr(v63v1, v63v2, t, "equal-map-v63-p-len")
+		bs63 = testMarshalErr(&v63v1, h, t, "enc-map-v63-p")
+		v63v2 = nil
+		testUnmarshalErr(&v63v2, bs63, h, t, "dec-map-v63-p-nil")
+		testDeepEqualErr(v63v1, v63v2, t, "equal-map-v63-p-nil")
+		// ...
+		if v == nil {
+			v63v2 = nil
+		} else {
+			v63v2 = make(map[float64]uintptr, len(v))
+		} // reset map
+		var v63v3, v63v4 typMapMapFloat64Uintptr
+		v63v3 = typMapMapFloat64Uintptr(v63v1)
+		v63v4 = typMapMapFloat64Uintptr(v63v2)
+		bs63 = testMarshalErr(v63v3, h, t, "enc-map-v63-custom")
+		testUnmarshalErr(v63v4, bs63, h, t, "dec-map-v63-p-len")
+		testDeepEqualErr(v63v3, v63v4, t, "equal-map-v63-p-len")
+	}
+
+	for _, v := range []map[float64]int{nil, {}, {22.2: 0, 11.1: 33}} {
+		// 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 = nil
+		} else {
+			v64v2 = make(map[float64]int, len(v))
+		} // reset map
+		testUnmarshalErr(v64v2, bs64, h, t, "dec-map-v64")
+		testDeepEqualErr(v64v1, v64v2, t, "equal-map-v64")
+		if v == nil {
+			v64v2 = nil
+		} else {
+			v64v2 = make(map[float64]int, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v64v2), bs64, h, t, "dec-map-v64-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v64v1, v64v2, t, "equal-map-v64-noaddr")
+		if v == nil {
+			v64v2 = nil
+		} else {
+			v64v2 = make(map[float64]int, len(v))
+		} // reset map
+		testUnmarshalErr(&v64v2, bs64, h, t, "dec-map-v64-p-len")
+		testDeepEqualErr(v64v1, v64v2, t, "equal-map-v64-p-len")
+		bs64 = testMarshalErr(&v64v1, h, t, "enc-map-v64-p")
+		v64v2 = nil
+		testUnmarshalErr(&v64v2, bs64, h, t, "dec-map-v64-p-nil")
+		testDeepEqualErr(v64v1, v64v2, t, "equal-map-v64-p-nil")
+		// ...
+		if v == nil {
+			v64v2 = nil
+		} else {
+			v64v2 = make(map[float64]int, len(v))
+		} // reset map
+		var v64v3, v64v4 typMapMapFloat64Int
+		v64v3 = typMapMapFloat64Int(v64v1)
+		v64v4 = typMapMapFloat64Int(v64v2)
+		bs64 = testMarshalErr(v64v3, h, t, "enc-map-v64-custom")
+		testUnmarshalErr(v64v4, bs64, h, t, "dec-map-v64-p-len")
+		testDeepEqualErr(v64v3, v64v4, t, "equal-map-v64-p-len")
+	}
+
+	for _, v := range []map[float64]int8{nil, {}, {22.2: 0, 11.1: 44}} {
+		// 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 = nil
+		} else {
+			v65v2 = make(map[float64]int8, len(v))
+		} // reset map
+		testUnmarshalErr(v65v2, bs65, h, t, "dec-map-v65")
+		testDeepEqualErr(v65v1, v65v2, t, "equal-map-v65")
+		if v == nil {
+			v65v2 = nil
+		} else {
+			v65v2 = make(map[float64]int8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v65v2), bs65, h, t, "dec-map-v65-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v65v1, v65v2, t, "equal-map-v65-noaddr")
+		if v == nil {
+			v65v2 = nil
+		} else {
+			v65v2 = make(map[float64]int8, len(v))
+		} // reset map
+		testUnmarshalErr(&v65v2, bs65, h, t, "dec-map-v65-p-len")
+		testDeepEqualErr(v65v1, v65v2, t, "equal-map-v65-p-len")
+		bs65 = testMarshalErr(&v65v1, h, t, "enc-map-v65-p")
+		v65v2 = nil
+		testUnmarshalErr(&v65v2, bs65, h, t, "dec-map-v65-p-nil")
+		testDeepEqualErr(v65v1, v65v2, t, "equal-map-v65-p-nil")
+		// ...
+		if v == nil {
+			v65v2 = nil
+		} else {
+			v65v2 = make(map[float64]int8, len(v))
+		} // reset map
+		var v65v3, v65v4 typMapMapFloat64Int8
+		v65v3 = typMapMapFloat64Int8(v65v1)
+		v65v4 = typMapMapFloat64Int8(v65v2)
+		bs65 = testMarshalErr(v65v3, h, t, "enc-map-v65-custom")
+		testUnmarshalErr(v65v4, bs65, h, t, "dec-map-v65-p-len")
+		testDeepEqualErr(v65v3, v65v4, t, "equal-map-v65-p-len")
+	}
+
+	for _, v := range []map[float64]int16{nil, {}, {22.2: 0, 11.1: 33}} {
+		// 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 = nil
+		} else {
+			v66v2 = make(map[float64]int16, len(v))
+		} // reset map
+		testUnmarshalErr(v66v2, bs66, h, t, "dec-map-v66")
+		testDeepEqualErr(v66v1, v66v2, t, "equal-map-v66")
+		if v == nil {
+			v66v2 = nil
+		} else {
+			v66v2 = make(map[float64]int16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v66v2), bs66, h, t, "dec-map-v66-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v66v1, v66v2, t, "equal-map-v66-noaddr")
+		if v == nil {
+			v66v2 = nil
+		} else {
+			v66v2 = make(map[float64]int16, len(v))
+		} // reset map
+		testUnmarshalErr(&v66v2, bs66, h, t, "dec-map-v66-p-len")
+		testDeepEqualErr(v66v1, v66v2, t, "equal-map-v66-p-len")
+		bs66 = testMarshalErr(&v66v1, h, t, "enc-map-v66-p")
+		v66v2 = nil
+		testUnmarshalErr(&v66v2, bs66, h, t, "dec-map-v66-p-nil")
+		testDeepEqualErr(v66v1, v66v2, t, "equal-map-v66-p-nil")
+		// ...
+		if v == nil {
+			v66v2 = nil
+		} else {
+			v66v2 = make(map[float64]int16, len(v))
+		} // reset map
+		var v66v3, v66v4 typMapMapFloat64Int16
+		v66v3 = typMapMapFloat64Int16(v66v1)
+		v66v4 = typMapMapFloat64Int16(v66v2)
+		bs66 = testMarshalErr(v66v3, h, t, "enc-map-v66-custom")
+		testUnmarshalErr(v66v4, bs66, h, t, "dec-map-v66-p-len")
+		testDeepEqualErr(v66v3, v66v4, t, "equal-map-v66-p-len")
+	}
+
+	for _, v := range []map[float64]int32{nil, {}, {22.2: 0, 11.1: 44}} {
+		// 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 = nil
+		} else {
+			v67v2 = make(map[float64]int32, len(v))
+		} // reset map
+		testUnmarshalErr(v67v2, bs67, h, t, "dec-map-v67")
+		testDeepEqualErr(v67v1, v67v2, t, "equal-map-v67")
+		if v == nil {
+			v67v2 = nil
+		} else {
+			v67v2 = make(map[float64]int32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v67v2), bs67, h, t, "dec-map-v67-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v67v1, v67v2, t, "equal-map-v67-noaddr")
+		if v == nil {
+			v67v2 = nil
+		} else {
+			v67v2 = make(map[float64]int32, len(v))
+		} // reset map
+		testUnmarshalErr(&v67v2, bs67, h, t, "dec-map-v67-p-len")
+		testDeepEqualErr(v67v1, v67v2, t, "equal-map-v67-p-len")
+		bs67 = testMarshalErr(&v67v1, h, t, "enc-map-v67-p")
+		v67v2 = nil
+		testUnmarshalErr(&v67v2, bs67, h, t, "dec-map-v67-p-nil")
+		testDeepEqualErr(v67v1, v67v2, t, "equal-map-v67-p-nil")
+		// ...
+		if v == nil {
+			v67v2 = nil
+		} else {
+			v67v2 = make(map[float64]int32, len(v))
+		} // reset map
+		var v67v3, v67v4 typMapMapFloat64Int32
+		v67v3 = typMapMapFloat64Int32(v67v1)
+		v67v4 = typMapMapFloat64Int32(v67v2)
+		bs67 = testMarshalErr(v67v3, h, t, "enc-map-v67-custom")
+		testUnmarshalErr(v67v4, bs67, h, t, "dec-map-v67-p-len")
+		testDeepEqualErr(v67v3, v67v4, t, "equal-map-v67-p-len")
+	}
+
+	for _, v := range []map[float64]int64{nil, {}, {22.2: 0, 11.1: 33}} {
+		// 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 = nil
+		} else {
+			v68v2 = make(map[float64]int64, len(v))
+		} // reset map
+		testUnmarshalErr(v68v2, bs68, h, t, "dec-map-v68")
+		testDeepEqualErr(v68v1, v68v2, t, "equal-map-v68")
+		if v == nil {
+			v68v2 = nil
+		} else {
+			v68v2 = make(map[float64]int64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v68v2), bs68, h, t, "dec-map-v68-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v68v1, v68v2, t, "equal-map-v68-noaddr")
+		if v == nil {
+			v68v2 = nil
+		} else {
+			v68v2 = make(map[float64]int64, len(v))
+		} // reset map
+		testUnmarshalErr(&v68v2, bs68, h, t, "dec-map-v68-p-len")
+		testDeepEqualErr(v68v1, v68v2, t, "equal-map-v68-p-len")
+		bs68 = testMarshalErr(&v68v1, h, t, "enc-map-v68-p")
+		v68v2 = nil
+		testUnmarshalErr(&v68v2, bs68, h, t, "dec-map-v68-p-nil")
+		testDeepEqualErr(v68v1, v68v2, t, "equal-map-v68-p-nil")
+		// ...
+		if v == nil {
+			v68v2 = nil
+		} else {
+			v68v2 = make(map[float64]int64, len(v))
+		} // reset map
+		var v68v3, v68v4 typMapMapFloat64Int64
+		v68v3 = typMapMapFloat64Int64(v68v1)
+		v68v4 = typMapMapFloat64Int64(v68v2)
+		bs68 = testMarshalErr(v68v3, h, t, "enc-map-v68-custom")
+		testUnmarshalErr(v68v4, bs68, h, t, "dec-map-v68-p-len")
+		testDeepEqualErr(v68v3, v68v4, t, "equal-map-v68-p-len")
+	}
+
+	for _, v := range []map[float64]float32{nil, {}, {22.2: 0, 11.1: 22.2}} {
+		// 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 = nil
+		} else {
+			v69v2 = make(map[float64]float32, len(v))
+		} // reset map
+		testUnmarshalErr(v69v2, bs69, h, t, "dec-map-v69")
+		testDeepEqualErr(v69v1, v69v2, t, "equal-map-v69")
+		if v == nil {
+			v69v2 = nil
+		} else {
+			v69v2 = make(map[float64]float32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v69v2), bs69, h, t, "dec-map-v69-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v69v1, v69v2, t, "equal-map-v69-noaddr")
+		if v == nil {
+			v69v2 = nil
+		} else {
+			v69v2 = make(map[float64]float32, len(v))
+		} // reset map
+		testUnmarshalErr(&v69v2, bs69, h, t, "dec-map-v69-p-len")
+		testDeepEqualErr(v69v1, v69v2, t, "equal-map-v69-p-len")
+		bs69 = testMarshalErr(&v69v1, h, t, "enc-map-v69-p")
+		v69v2 = nil
+		testUnmarshalErr(&v69v2, bs69, h, t, "dec-map-v69-p-nil")
+		testDeepEqualErr(v69v1, v69v2, t, "equal-map-v69-p-nil")
+		// ...
+		if v == nil {
+			v69v2 = nil
+		} else {
+			v69v2 = make(map[float64]float32, len(v))
+		} // reset map
+		var v69v3, v69v4 typMapMapFloat64Float32
+		v69v3 = typMapMapFloat64Float32(v69v1)
+		v69v4 = typMapMapFloat64Float32(v69v2)
+		bs69 = testMarshalErr(v69v3, h, t, "enc-map-v69-custom")
+		testUnmarshalErr(v69v4, bs69, h, t, "dec-map-v69-p-len")
+		testDeepEqualErr(v69v3, v69v4, t, "equal-map-v69-p-len")
+	}
+
+	for _, v := range []map[float64]float64{nil, {}, {11.1: 0, 22.2: 11.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 = nil
+		} else {
+			v70v2 = make(map[float64]float64, len(v))
+		} // reset map
+		testUnmarshalErr(v70v2, bs70, h, t, "dec-map-v70")
+		testDeepEqualErr(v70v1, v70v2, t, "equal-map-v70")
+		if v == nil {
+			v70v2 = nil
+		} else {
+			v70v2 = make(map[float64]float64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v70v2), bs70, h, t, "dec-map-v70-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v70v1, v70v2, t, "equal-map-v70-noaddr")
+		if v == nil {
+			v70v2 = nil
+		} else {
+			v70v2 = make(map[float64]float64, len(v))
+		} // reset map
+		testUnmarshalErr(&v70v2, bs70, h, t, "dec-map-v70-p-len")
+		testDeepEqualErr(v70v1, v70v2, t, "equal-map-v70-p-len")
+		bs70 = testMarshalErr(&v70v1, h, t, "enc-map-v70-p")
+		v70v2 = nil
+		testUnmarshalErr(&v70v2, bs70, h, t, "dec-map-v70-p-nil")
+		testDeepEqualErr(v70v1, v70v2, t, "equal-map-v70-p-nil")
+		// ...
+		if v == nil {
+			v70v2 = nil
+		} else {
+			v70v2 = make(map[float64]float64, len(v))
+		} // reset map
+		var v70v3, v70v4 typMapMapFloat64Float64
+		v70v3 = typMapMapFloat64Float64(v70v1)
+		v70v4 = typMapMapFloat64Float64(v70v2)
+		bs70 = testMarshalErr(v70v3, h, t, "enc-map-v70-custom")
+		testUnmarshalErr(v70v4, bs70, h, t, "dec-map-v70-p-len")
+		testDeepEqualErr(v70v3, v70v4, t, "equal-map-v70-p-len")
+	}
+
+	for _, v := range []map[float64]bool{nil, {}, {22.2: false, 11.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 = nil
+		} else {
+			v71v2 = make(map[float64]bool, len(v))
+		} // reset map
+		testUnmarshalErr(v71v2, bs71, h, t, "dec-map-v71")
+		testDeepEqualErr(v71v1, v71v2, t, "equal-map-v71")
+		if v == nil {
+			v71v2 = nil
+		} else {
+			v71v2 = make(map[float64]bool, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v71v2), bs71, h, t, "dec-map-v71-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v71v1, v71v2, t, "equal-map-v71-noaddr")
+		if v == nil {
+			v71v2 = nil
+		} else {
+			v71v2 = make(map[float64]bool, len(v))
+		} // reset map
+		testUnmarshalErr(&v71v2, bs71, h, t, "dec-map-v71-p-len")
+		testDeepEqualErr(v71v1, v71v2, t, "equal-map-v71-p-len")
+		bs71 = testMarshalErr(&v71v1, h, t, "enc-map-v71-p")
+		v71v2 = nil
+		testUnmarshalErr(&v71v2, bs71, h, t, "dec-map-v71-p-nil")
+		testDeepEqualErr(v71v1, v71v2, t, "equal-map-v71-p-nil")
+		// ...
+		if v == nil {
+			v71v2 = nil
+		} else {
+			v71v2 = make(map[float64]bool, len(v))
+		} // reset map
+		var v71v3, v71v4 typMapMapFloat64Bool
+		v71v3 = typMapMapFloat64Bool(v71v1)
+		v71v4 = typMapMapFloat64Bool(v71v2)
+		bs71 = testMarshalErr(v71v3, h, t, "enc-map-v71-custom")
+		testUnmarshalErr(v71v4, bs71, h, t, "dec-map-v71-p-len")
+		testDeepEqualErr(v71v3, v71v4, t, "equal-map-v71-p-len")
+	}
+
+	for _, v := range []map[uint]interface{}{nil, {}, {44: nil, 33: "string-is-an-interface-2"}} {
+		// 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 = nil
+		} else {
+			v74v2 = make(map[uint]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(v74v2, bs74, h, t, "dec-map-v74")
+		testDeepEqualErr(v74v1, v74v2, t, "equal-map-v74")
+		if v == nil {
+			v74v2 = nil
+		} else {
+			v74v2 = make(map[uint]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v74v2), bs74, h, t, "dec-map-v74-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v74v1, v74v2, t, "equal-map-v74-noaddr")
+		if v == nil {
+			v74v2 = nil
+		} else {
+			v74v2 = make(map[uint]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(&v74v2, bs74, h, t, "dec-map-v74-p-len")
+		testDeepEqualErr(v74v1, v74v2, t, "equal-map-v74-p-len")
+		bs74 = testMarshalErr(&v74v1, h, t, "enc-map-v74-p")
+		v74v2 = nil
+		testUnmarshalErr(&v74v2, bs74, h, t, "dec-map-v74-p-nil")
+		testDeepEqualErr(v74v1, v74v2, t, "equal-map-v74-p-nil")
+		// ...
+		if v == nil {
+			v74v2 = nil
+		} else {
+			v74v2 = make(map[uint]interface{}, len(v))
+		} // reset map
+		var v74v3, v74v4 typMapMapUintIntf
+		v74v3 = typMapMapUintIntf(v74v1)
+		v74v4 = typMapMapUintIntf(v74v2)
+		bs74 = testMarshalErr(v74v3, h, t, "enc-map-v74-custom")
+		testUnmarshalErr(v74v4, bs74, h, t, "dec-map-v74-p-len")
+		testDeepEqualErr(v74v3, v74v4, t, "equal-map-v74-p-len")
+	}
+
+	for _, v := range []map[uint]string{nil, {}, {44: "", 33: "some-string-2"}} {
+		// 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 = nil
+		} else {
+			v75v2 = make(map[uint]string, len(v))
+		} // reset map
+		testUnmarshalErr(v75v2, bs75, h, t, "dec-map-v75")
+		testDeepEqualErr(v75v1, v75v2, t, "equal-map-v75")
+		if v == nil {
+			v75v2 = nil
+		} else {
+			v75v2 = make(map[uint]string, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v75v2), bs75, h, t, "dec-map-v75-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v75v1, v75v2, t, "equal-map-v75-noaddr")
+		if v == nil {
+			v75v2 = nil
+		} else {
+			v75v2 = make(map[uint]string, len(v))
+		} // reset map
+		testUnmarshalErr(&v75v2, bs75, h, t, "dec-map-v75-p-len")
+		testDeepEqualErr(v75v1, v75v2, t, "equal-map-v75-p-len")
+		bs75 = testMarshalErr(&v75v1, h, t, "enc-map-v75-p")
+		v75v2 = nil
+		testUnmarshalErr(&v75v2, bs75, h, t, "dec-map-v75-p-nil")
+		testDeepEqualErr(v75v1, v75v2, t, "equal-map-v75-p-nil")
+		// ...
+		if v == nil {
+			v75v2 = nil
+		} else {
+			v75v2 = make(map[uint]string, len(v))
+		} // reset map
+		var v75v3, v75v4 typMapMapUintString
+		v75v3 = typMapMapUintString(v75v1)
+		v75v4 = typMapMapUintString(v75v2)
+		bs75 = testMarshalErr(v75v3, h, t, "enc-map-v75-custom")
+		testUnmarshalErr(v75v4, bs75, h, t, "dec-map-v75-p-len")
+		testDeepEqualErr(v75v3, v75v4, t, "equal-map-v75-p-len")
+	}
+
+	for _, v := range []map[uint]uint{nil, {}, {44: 0, 33: 44}} {
+		// 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 = nil
+		} else {
+			v76v2 = make(map[uint]uint, len(v))
+		} // reset map
+		testUnmarshalErr(v76v2, bs76, h, t, "dec-map-v76")
+		testDeepEqualErr(v76v1, v76v2, t, "equal-map-v76")
+		if v == nil {
+			v76v2 = nil
+		} else {
+			v76v2 = make(map[uint]uint, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v76v2), bs76, h, t, "dec-map-v76-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v76v1, v76v2, t, "equal-map-v76-noaddr")
+		if v == nil {
+			v76v2 = nil
+		} else {
+			v76v2 = make(map[uint]uint, len(v))
+		} // reset map
+		testUnmarshalErr(&v76v2, bs76, h, t, "dec-map-v76-p-len")
+		testDeepEqualErr(v76v1, v76v2, t, "equal-map-v76-p-len")
+		bs76 = testMarshalErr(&v76v1, h, t, "enc-map-v76-p")
+		v76v2 = nil
+		testUnmarshalErr(&v76v2, bs76, h, t, "dec-map-v76-p-nil")
+		testDeepEqualErr(v76v1, v76v2, t, "equal-map-v76-p-nil")
+		// ...
+		if v == nil {
+			v76v2 = nil
+		} else {
+			v76v2 = make(map[uint]uint, len(v))
+		} // reset map
+		var v76v3, v76v4 typMapMapUintUint
+		v76v3 = typMapMapUintUint(v76v1)
+		v76v4 = typMapMapUintUint(v76v2)
+		bs76 = testMarshalErr(v76v3, h, t, "enc-map-v76-custom")
+		testUnmarshalErr(v76v4, bs76, h, t, "dec-map-v76-p-len")
+		testDeepEqualErr(v76v3, v76v4, t, "equal-map-v76-p-len")
+	}
+
+	for _, v := range []map[uint]uint8{nil, {}, {33: 0, 44: 33}} {
+		// 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 = nil
+		} else {
+			v77v2 = make(map[uint]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(v77v2, bs77, h, t, "dec-map-v77")
+		testDeepEqualErr(v77v1, v77v2, t, "equal-map-v77")
+		if v == nil {
+			v77v2 = nil
+		} else {
+			v77v2 = make(map[uint]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v77v2), bs77, h, t, "dec-map-v77-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v77v1, v77v2, t, "equal-map-v77-noaddr")
+		if v == nil {
+			v77v2 = nil
+		} else {
+			v77v2 = make(map[uint]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(&v77v2, bs77, h, t, "dec-map-v77-p-len")
+		testDeepEqualErr(v77v1, v77v2, t, "equal-map-v77-p-len")
+		bs77 = testMarshalErr(&v77v1, h, t, "enc-map-v77-p")
+		v77v2 = nil
+		testUnmarshalErr(&v77v2, bs77, h, t, "dec-map-v77-p-nil")
+		testDeepEqualErr(v77v1, v77v2, t, "equal-map-v77-p-nil")
+		// ...
+		if v == nil {
+			v77v2 = nil
+		} else {
+			v77v2 = make(map[uint]uint8, len(v))
+		} // reset map
+		var v77v3, v77v4 typMapMapUintUint8
+		v77v3 = typMapMapUintUint8(v77v1)
+		v77v4 = typMapMapUintUint8(v77v2)
+		bs77 = testMarshalErr(v77v3, h, t, "enc-map-v77-custom")
+		testUnmarshalErr(v77v4, bs77, h, t, "dec-map-v77-p-len")
+		testDeepEqualErr(v77v3, v77v4, t, "equal-map-v77-p-len")
+	}
+
+	for _, v := range []map[uint]uint16{nil, {}, {44: 0, 33: 44}} {
+		// 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 = nil
+		} else {
+			v78v2 = make(map[uint]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(v78v2, bs78, h, t, "dec-map-v78")
+		testDeepEqualErr(v78v1, v78v2, t, "equal-map-v78")
+		if v == nil {
+			v78v2 = nil
+		} else {
+			v78v2 = make(map[uint]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v78v2), bs78, h, t, "dec-map-v78-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v78v1, v78v2, t, "equal-map-v78-noaddr")
+		if v == nil {
+			v78v2 = nil
+		} else {
+			v78v2 = make(map[uint]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(&v78v2, bs78, h, t, "dec-map-v78-p-len")
+		testDeepEqualErr(v78v1, v78v2, t, "equal-map-v78-p-len")
+		bs78 = testMarshalErr(&v78v1, h, t, "enc-map-v78-p")
+		v78v2 = nil
+		testUnmarshalErr(&v78v2, bs78, h, t, "dec-map-v78-p-nil")
+		testDeepEqualErr(v78v1, v78v2, t, "equal-map-v78-p-nil")
+		// ...
+		if v == nil {
+			v78v2 = nil
+		} else {
+			v78v2 = make(map[uint]uint16, len(v))
+		} // reset map
+		var v78v3, v78v4 typMapMapUintUint16
+		v78v3 = typMapMapUintUint16(v78v1)
+		v78v4 = typMapMapUintUint16(v78v2)
+		bs78 = testMarshalErr(v78v3, h, t, "enc-map-v78-custom")
+		testUnmarshalErr(v78v4, bs78, h, t, "dec-map-v78-p-len")
+		testDeepEqualErr(v78v3, v78v4, t, "equal-map-v78-p-len")
+	}
+
+	for _, v := range []map[uint]uint32{nil, {}, {33: 0, 44: 33}} {
+		// 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 = nil
+		} else {
+			v79v2 = make(map[uint]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(v79v2, bs79, h, t, "dec-map-v79")
+		testDeepEqualErr(v79v1, v79v2, t, "equal-map-v79")
+		if v == nil {
+			v79v2 = nil
+		} else {
+			v79v2 = make(map[uint]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v79v2), bs79, h, t, "dec-map-v79-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v79v1, v79v2, t, "equal-map-v79-noaddr")
+		if v == nil {
+			v79v2 = nil
+		} else {
+			v79v2 = make(map[uint]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(&v79v2, bs79, h, t, "dec-map-v79-p-len")
+		testDeepEqualErr(v79v1, v79v2, t, "equal-map-v79-p-len")
+		bs79 = testMarshalErr(&v79v1, h, t, "enc-map-v79-p")
+		v79v2 = nil
+		testUnmarshalErr(&v79v2, bs79, h, t, "dec-map-v79-p-nil")
+		testDeepEqualErr(v79v1, v79v2, t, "equal-map-v79-p-nil")
+		// ...
+		if v == nil {
+			v79v2 = nil
+		} else {
+			v79v2 = make(map[uint]uint32, len(v))
+		} // reset map
+		var v79v3, v79v4 typMapMapUintUint32
+		v79v3 = typMapMapUintUint32(v79v1)
+		v79v4 = typMapMapUintUint32(v79v2)
+		bs79 = testMarshalErr(v79v3, h, t, "enc-map-v79-custom")
+		testUnmarshalErr(v79v4, bs79, h, t, "dec-map-v79-p-len")
+		testDeepEqualErr(v79v3, v79v4, t, "equal-map-v79-p-len")
+	}
+
+	for _, v := range []map[uint]uint64{nil, {}, {44: 0, 33: 44}} {
+		// 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 = nil
+		} else {
+			v80v2 = make(map[uint]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(v80v2, bs80, h, t, "dec-map-v80")
+		testDeepEqualErr(v80v1, v80v2, t, "equal-map-v80")
+		if v == nil {
+			v80v2 = nil
+		} else {
+			v80v2 = make(map[uint]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v80v2), bs80, h, t, "dec-map-v80-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v80v1, v80v2, t, "equal-map-v80-noaddr")
+		if v == nil {
+			v80v2 = nil
+		} else {
+			v80v2 = make(map[uint]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(&v80v2, bs80, h, t, "dec-map-v80-p-len")
+		testDeepEqualErr(v80v1, v80v2, t, "equal-map-v80-p-len")
+		bs80 = testMarshalErr(&v80v1, h, t, "enc-map-v80-p")
+		v80v2 = nil
+		testUnmarshalErr(&v80v2, bs80, h, t, "dec-map-v80-p-nil")
+		testDeepEqualErr(v80v1, v80v2, t, "equal-map-v80-p-nil")
+		// ...
+		if v == nil {
+			v80v2 = nil
+		} else {
+			v80v2 = make(map[uint]uint64, len(v))
+		} // reset map
+		var v80v3, v80v4 typMapMapUintUint64
+		v80v3 = typMapMapUintUint64(v80v1)
+		v80v4 = typMapMapUintUint64(v80v2)
+		bs80 = testMarshalErr(v80v3, h, t, "enc-map-v80-custom")
+		testUnmarshalErr(v80v4, bs80, h, t, "dec-map-v80-p-len")
+		testDeepEqualErr(v80v3, v80v4, t, "equal-map-v80-p-len")
+	}
+
+	for _, v := range []map[uint]uintptr{nil, {}, {33: 0, 44: 33}} {
+		// 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 = nil
+		} else {
+			v81v2 = make(map[uint]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(v81v2, bs81, h, t, "dec-map-v81")
+		testDeepEqualErr(v81v1, v81v2, t, "equal-map-v81")
+		if v == nil {
+			v81v2 = nil
+		} else {
+			v81v2 = make(map[uint]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v81v2), bs81, h, t, "dec-map-v81-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v81v1, v81v2, t, "equal-map-v81-noaddr")
+		if v == nil {
+			v81v2 = nil
+		} else {
+			v81v2 = make(map[uint]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(&v81v2, bs81, h, t, "dec-map-v81-p-len")
+		testDeepEqualErr(v81v1, v81v2, t, "equal-map-v81-p-len")
+		bs81 = testMarshalErr(&v81v1, h, t, "enc-map-v81-p")
+		v81v2 = nil
+		testUnmarshalErr(&v81v2, bs81, h, t, "dec-map-v81-p-nil")
+		testDeepEqualErr(v81v1, v81v2, t, "equal-map-v81-p-nil")
+		// ...
+		if v == nil {
+			v81v2 = nil
+		} else {
+			v81v2 = make(map[uint]uintptr, len(v))
+		} // reset map
+		var v81v3, v81v4 typMapMapUintUintptr
+		v81v3 = typMapMapUintUintptr(v81v1)
+		v81v4 = typMapMapUintUintptr(v81v2)
+		bs81 = testMarshalErr(v81v3, h, t, "enc-map-v81-custom")
+		testUnmarshalErr(v81v4, bs81, h, t, "dec-map-v81-p-len")
+		testDeepEqualErr(v81v3, v81v4, t, "equal-map-v81-p-len")
+	}
+
+	for _, v := range []map[uint]int{nil, {}, {44: 0, 33: 44}} {
+		// 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 = nil
+		} else {
+			v82v2 = make(map[uint]int, len(v))
+		} // reset map
+		testUnmarshalErr(v82v2, bs82, h, t, "dec-map-v82")
+		testDeepEqualErr(v82v1, v82v2, t, "equal-map-v82")
+		if v == nil {
+			v82v2 = nil
+		} else {
+			v82v2 = make(map[uint]int, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v82v2), bs82, h, t, "dec-map-v82-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v82v1, v82v2, t, "equal-map-v82-noaddr")
+		if v == nil {
+			v82v2 = nil
+		} else {
+			v82v2 = make(map[uint]int, len(v))
+		} // reset map
+		testUnmarshalErr(&v82v2, bs82, h, t, "dec-map-v82-p-len")
+		testDeepEqualErr(v82v1, v82v2, t, "equal-map-v82-p-len")
+		bs82 = testMarshalErr(&v82v1, h, t, "enc-map-v82-p")
+		v82v2 = nil
+		testUnmarshalErr(&v82v2, bs82, h, t, "dec-map-v82-p-nil")
+		testDeepEqualErr(v82v1, v82v2, t, "equal-map-v82-p-nil")
+		// ...
+		if v == nil {
+			v82v2 = nil
+		} else {
+			v82v2 = make(map[uint]int, len(v))
+		} // reset map
+		var v82v3, v82v4 typMapMapUintInt
+		v82v3 = typMapMapUintInt(v82v1)
+		v82v4 = typMapMapUintInt(v82v2)
+		bs82 = testMarshalErr(v82v3, h, t, "enc-map-v82-custom")
+		testUnmarshalErr(v82v4, bs82, h, t, "dec-map-v82-p-len")
+		testDeepEqualErr(v82v3, v82v4, t, "equal-map-v82-p-len")
+	}
+
+	for _, v := range []map[uint]int8{nil, {}, {33: 0, 44: 33}} {
+		// 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 = nil
+		} else {
+			v83v2 = make(map[uint]int8, len(v))
+		} // reset map
+		testUnmarshalErr(v83v2, bs83, h, t, "dec-map-v83")
+		testDeepEqualErr(v83v1, v83v2, t, "equal-map-v83")
+		if v == nil {
+			v83v2 = nil
+		} else {
+			v83v2 = make(map[uint]int8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v83v2), bs83, h, t, "dec-map-v83-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v83v1, v83v2, t, "equal-map-v83-noaddr")
+		if v == nil {
+			v83v2 = nil
+		} else {
+			v83v2 = make(map[uint]int8, len(v))
+		} // reset map
+		testUnmarshalErr(&v83v2, bs83, h, t, "dec-map-v83-p-len")
+		testDeepEqualErr(v83v1, v83v2, t, "equal-map-v83-p-len")
+		bs83 = testMarshalErr(&v83v1, h, t, "enc-map-v83-p")
+		v83v2 = nil
+		testUnmarshalErr(&v83v2, bs83, h, t, "dec-map-v83-p-nil")
+		testDeepEqualErr(v83v1, v83v2, t, "equal-map-v83-p-nil")
+		// ...
+		if v == nil {
+			v83v2 = nil
+		} else {
+			v83v2 = make(map[uint]int8, len(v))
+		} // reset map
+		var v83v3, v83v4 typMapMapUintInt8
+		v83v3 = typMapMapUintInt8(v83v1)
+		v83v4 = typMapMapUintInt8(v83v2)
+		bs83 = testMarshalErr(v83v3, h, t, "enc-map-v83-custom")
+		testUnmarshalErr(v83v4, bs83, h, t, "dec-map-v83-p-len")
+		testDeepEqualErr(v83v3, v83v4, t, "equal-map-v83-p-len")
+	}
+
+	for _, v := range []map[uint]int16{nil, {}, {44: 0, 33: 44}} {
+		// 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 = nil
+		} else {
+			v84v2 = make(map[uint]int16, len(v))
+		} // reset map
+		testUnmarshalErr(v84v2, bs84, h, t, "dec-map-v84")
+		testDeepEqualErr(v84v1, v84v2, t, "equal-map-v84")
+		if v == nil {
+			v84v2 = nil
+		} else {
+			v84v2 = make(map[uint]int16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v84v2), bs84, h, t, "dec-map-v84-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v84v1, v84v2, t, "equal-map-v84-noaddr")
+		if v == nil {
+			v84v2 = nil
+		} else {
+			v84v2 = make(map[uint]int16, len(v))
+		} // reset map
+		testUnmarshalErr(&v84v2, bs84, h, t, "dec-map-v84-p-len")
+		testDeepEqualErr(v84v1, v84v2, t, "equal-map-v84-p-len")
+		bs84 = testMarshalErr(&v84v1, h, t, "enc-map-v84-p")
+		v84v2 = nil
+		testUnmarshalErr(&v84v2, bs84, h, t, "dec-map-v84-p-nil")
+		testDeepEqualErr(v84v1, v84v2, t, "equal-map-v84-p-nil")
+		// ...
+		if v == nil {
+			v84v2 = nil
+		} else {
+			v84v2 = make(map[uint]int16, len(v))
+		} // reset map
+		var v84v3, v84v4 typMapMapUintInt16
+		v84v3 = typMapMapUintInt16(v84v1)
+		v84v4 = typMapMapUintInt16(v84v2)
+		bs84 = testMarshalErr(v84v3, h, t, "enc-map-v84-custom")
+		testUnmarshalErr(v84v4, bs84, h, t, "dec-map-v84-p-len")
+		testDeepEqualErr(v84v3, v84v4, t, "equal-map-v84-p-len")
+	}
+
+	for _, v := range []map[uint]int32{nil, {}, {33: 0, 44: 33}} {
+		// 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 = nil
+		} else {
+			v85v2 = make(map[uint]int32, len(v))
+		} // reset map
+		testUnmarshalErr(v85v2, bs85, h, t, "dec-map-v85")
+		testDeepEqualErr(v85v1, v85v2, t, "equal-map-v85")
+		if v == nil {
+			v85v2 = nil
+		} else {
+			v85v2 = make(map[uint]int32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v85v2), bs85, h, t, "dec-map-v85-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v85v1, v85v2, t, "equal-map-v85-noaddr")
+		if v == nil {
+			v85v2 = nil
+		} else {
+			v85v2 = make(map[uint]int32, len(v))
+		} // reset map
+		testUnmarshalErr(&v85v2, bs85, h, t, "dec-map-v85-p-len")
+		testDeepEqualErr(v85v1, v85v2, t, "equal-map-v85-p-len")
+		bs85 = testMarshalErr(&v85v1, h, t, "enc-map-v85-p")
+		v85v2 = nil
+		testUnmarshalErr(&v85v2, bs85, h, t, "dec-map-v85-p-nil")
+		testDeepEqualErr(v85v1, v85v2, t, "equal-map-v85-p-nil")
+		// ...
+		if v == nil {
+			v85v2 = nil
+		} else {
+			v85v2 = make(map[uint]int32, len(v))
+		} // reset map
+		var v85v3, v85v4 typMapMapUintInt32
+		v85v3 = typMapMapUintInt32(v85v1)
+		v85v4 = typMapMapUintInt32(v85v2)
+		bs85 = testMarshalErr(v85v3, h, t, "enc-map-v85-custom")
+		testUnmarshalErr(v85v4, bs85, h, t, "dec-map-v85-p-len")
+		testDeepEqualErr(v85v3, v85v4, t, "equal-map-v85-p-len")
+	}
+
+	for _, v := range []map[uint]int64{nil, {}, {44: 0, 33: 44}} {
+		// 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 = nil
+		} else {
+			v86v2 = make(map[uint]int64, len(v))
+		} // reset map
+		testUnmarshalErr(v86v2, bs86, h, t, "dec-map-v86")
+		testDeepEqualErr(v86v1, v86v2, t, "equal-map-v86")
+		if v == nil {
+			v86v2 = nil
+		} else {
+			v86v2 = make(map[uint]int64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v86v2), bs86, h, t, "dec-map-v86-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v86v1, v86v2, t, "equal-map-v86-noaddr")
+		if v == nil {
+			v86v2 = nil
+		} else {
+			v86v2 = make(map[uint]int64, len(v))
+		} // reset map
+		testUnmarshalErr(&v86v2, bs86, h, t, "dec-map-v86-p-len")
+		testDeepEqualErr(v86v1, v86v2, t, "equal-map-v86-p-len")
+		bs86 = testMarshalErr(&v86v1, h, t, "enc-map-v86-p")
+		v86v2 = nil
+		testUnmarshalErr(&v86v2, bs86, h, t, "dec-map-v86-p-nil")
+		testDeepEqualErr(v86v1, v86v2, t, "equal-map-v86-p-nil")
+		// ...
+		if v == nil {
+			v86v2 = nil
+		} else {
+			v86v2 = make(map[uint]int64, len(v))
+		} // reset map
+		var v86v3, v86v4 typMapMapUintInt64
+		v86v3 = typMapMapUintInt64(v86v1)
+		v86v4 = typMapMapUintInt64(v86v2)
+		bs86 = testMarshalErr(v86v3, h, t, "enc-map-v86-custom")
+		testUnmarshalErr(v86v4, bs86, h, t, "dec-map-v86-p-len")
+		testDeepEqualErr(v86v3, v86v4, t, "equal-map-v86-p-len")
+	}
+
+	for _, v := range []map[uint]float32{nil, {}, {33: 0, 44: 22.2}} {
+		// 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 = nil
+		} else {
+			v87v2 = make(map[uint]float32, len(v))
+		} // reset map
+		testUnmarshalErr(v87v2, bs87, h, t, "dec-map-v87")
+		testDeepEqualErr(v87v1, v87v2, t, "equal-map-v87")
+		if v == nil {
+			v87v2 = nil
+		} else {
+			v87v2 = make(map[uint]float32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v87v2), bs87, h, t, "dec-map-v87-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v87v1, v87v2, t, "equal-map-v87-noaddr")
+		if v == nil {
+			v87v2 = nil
+		} else {
+			v87v2 = make(map[uint]float32, len(v))
+		} // reset map
+		testUnmarshalErr(&v87v2, bs87, h, t, "dec-map-v87-p-len")
+		testDeepEqualErr(v87v1, v87v2, t, "equal-map-v87-p-len")
+		bs87 = testMarshalErr(&v87v1, h, t, "enc-map-v87-p")
+		v87v2 = nil
+		testUnmarshalErr(&v87v2, bs87, h, t, "dec-map-v87-p-nil")
+		testDeepEqualErr(v87v1, v87v2, t, "equal-map-v87-p-nil")
+		// ...
+		if v == nil {
+			v87v2 = nil
+		} else {
+			v87v2 = make(map[uint]float32, len(v))
+		} // reset map
+		var v87v3, v87v4 typMapMapUintFloat32
+		v87v3 = typMapMapUintFloat32(v87v1)
+		v87v4 = typMapMapUintFloat32(v87v2)
+		bs87 = testMarshalErr(v87v3, h, t, "enc-map-v87-custom")
+		testUnmarshalErr(v87v4, bs87, h, t, "dec-map-v87-p-len")
+		testDeepEqualErr(v87v3, v87v4, t, "equal-map-v87-p-len")
+	}
+
+	for _, v := range []map[uint]float64{nil, {}, {33: 0, 44: 11.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 = nil
+		} else {
+			v88v2 = make(map[uint]float64, len(v))
+		} // reset map
+		testUnmarshalErr(v88v2, bs88, h, t, "dec-map-v88")
+		testDeepEqualErr(v88v1, v88v2, t, "equal-map-v88")
+		if v == nil {
+			v88v2 = nil
+		} else {
+			v88v2 = make(map[uint]float64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v88v2), bs88, h, t, "dec-map-v88-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v88v1, v88v2, t, "equal-map-v88-noaddr")
+		if v == nil {
+			v88v2 = nil
+		} else {
+			v88v2 = make(map[uint]float64, len(v))
+		} // reset map
+		testUnmarshalErr(&v88v2, bs88, h, t, "dec-map-v88-p-len")
+		testDeepEqualErr(v88v1, v88v2, t, "equal-map-v88-p-len")
+		bs88 = testMarshalErr(&v88v1, h, t, "enc-map-v88-p")
+		v88v2 = nil
+		testUnmarshalErr(&v88v2, bs88, h, t, "dec-map-v88-p-nil")
+		testDeepEqualErr(v88v1, v88v2, t, "equal-map-v88-p-nil")
+		// ...
+		if v == nil {
+			v88v2 = nil
+		} else {
+			v88v2 = make(map[uint]float64, len(v))
+		} // reset map
+		var v88v3, v88v4 typMapMapUintFloat64
+		v88v3 = typMapMapUintFloat64(v88v1)
+		v88v4 = typMapMapUintFloat64(v88v2)
+		bs88 = testMarshalErr(v88v3, h, t, "enc-map-v88-custom")
+		testUnmarshalErr(v88v4, bs88, h, t, "dec-map-v88-p-len")
+		testDeepEqualErr(v88v3, v88v4, t, "equal-map-v88-p-len")
+	}
+
+	for _, v := range []map[uint]bool{nil, {}, {33: false, 44: 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 = nil
+		} else {
+			v89v2 = make(map[uint]bool, len(v))
+		} // reset map
+		testUnmarshalErr(v89v2, bs89, h, t, "dec-map-v89")
+		testDeepEqualErr(v89v1, v89v2, t, "equal-map-v89")
+		if v == nil {
+			v89v2 = nil
+		} else {
+			v89v2 = make(map[uint]bool, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v89v2), bs89, h, t, "dec-map-v89-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v89v1, v89v2, t, "equal-map-v89-noaddr")
+		if v == nil {
+			v89v2 = nil
+		} else {
+			v89v2 = make(map[uint]bool, len(v))
+		} // reset map
+		testUnmarshalErr(&v89v2, bs89, h, t, "dec-map-v89-p-len")
+		testDeepEqualErr(v89v1, v89v2, t, "equal-map-v89-p-len")
+		bs89 = testMarshalErr(&v89v1, h, t, "enc-map-v89-p")
+		v89v2 = nil
+		testUnmarshalErr(&v89v2, bs89, h, t, "dec-map-v89-p-nil")
+		testDeepEqualErr(v89v1, v89v2, t, "equal-map-v89-p-nil")
+		// ...
+		if v == nil {
+			v89v2 = nil
+		} else {
+			v89v2 = make(map[uint]bool, len(v))
+		} // reset map
+		var v89v3, v89v4 typMapMapUintBool
+		v89v3 = typMapMapUintBool(v89v1)
+		v89v4 = typMapMapUintBool(v89v2)
+		bs89 = testMarshalErr(v89v3, h, t, "enc-map-v89-custom")
+		testUnmarshalErr(v89v4, bs89, h, t, "dec-map-v89-p-len")
+		testDeepEqualErr(v89v3, v89v4, t, "equal-map-v89-p-len")
+	}
+
+	for _, v := range []map[uint8]interface{}{nil, {}, {33: nil, 44: "string-is-an-interface"}} {
+		// fmt.Printf(">>>> running mammoth map v92: %v\n", v)
+		var v92v1, v92v2 map[uint8]interface{}
+		v92v1 = v
+		bs92 := testMarshalErr(v92v1, h, t, "enc-map-v92")
+		if v == nil {
+			v92v2 = nil
+		} else {
+			v92v2 = make(map[uint8]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(v92v2, bs92, h, t, "dec-map-v92")
+		testDeepEqualErr(v92v1, v92v2, t, "equal-map-v92")
+		if v == nil {
+			v92v2 = nil
+		} else {
+			v92v2 = make(map[uint8]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v92v2), bs92, h, t, "dec-map-v92-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v92v1, v92v2, t, "equal-map-v92-noaddr")
+		if v == nil {
+			v92v2 = nil
+		} else {
+			v92v2 = make(map[uint8]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(&v92v2, bs92, h, t, "dec-map-v92-p-len")
+		testDeepEqualErr(v92v1, v92v2, t, "equal-map-v92-p-len")
+		bs92 = testMarshalErr(&v92v1, h, t, "enc-map-v92-p")
+		v92v2 = nil
+		testUnmarshalErr(&v92v2, bs92, h, t, "dec-map-v92-p-nil")
+		testDeepEqualErr(v92v1, v92v2, t, "equal-map-v92-p-nil")
+		// ...
+		if v == nil {
+			v92v2 = nil
+		} else {
+			v92v2 = make(map[uint8]interface{}, len(v))
+		} // reset map
+		var v92v3, v92v4 typMapMapUint8Intf
+		v92v3 = typMapMapUint8Intf(v92v1)
+		v92v4 = typMapMapUint8Intf(v92v2)
+		bs92 = testMarshalErr(v92v3, h, t, "enc-map-v92-custom")
+		testUnmarshalErr(v92v4, bs92, h, t, "dec-map-v92-p-len")
+		testDeepEqualErr(v92v3, v92v4, t, "equal-map-v92-p-len")
+	}
+
+	for _, v := range []map[uint8]string{nil, {}, {33: "", 44: "some-string"}} {
+		// fmt.Printf(">>>> running mammoth map v93: %v\n", v)
+		var v93v1, v93v2 map[uint8]string
+		v93v1 = v
+		bs93 := testMarshalErr(v93v1, h, t, "enc-map-v93")
+		if v == nil {
+			v93v2 = nil
+		} else {
+			v93v2 = make(map[uint8]string, len(v))
+		} // reset map
+		testUnmarshalErr(v93v2, bs93, h, t, "dec-map-v93")
+		testDeepEqualErr(v93v1, v93v2, t, "equal-map-v93")
+		if v == nil {
+			v93v2 = nil
+		} else {
+			v93v2 = make(map[uint8]string, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v93v2), bs93, h, t, "dec-map-v93-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v93v1, v93v2, t, "equal-map-v93-noaddr")
+		if v == nil {
+			v93v2 = nil
+		} else {
+			v93v2 = make(map[uint8]string, len(v))
+		} // reset map
+		testUnmarshalErr(&v93v2, bs93, h, t, "dec-map-v93-p-len")
+		testDeepEqualErr(v93v1, v93v2, t, "equal-map-v93-p-len")
+		bs93 = testMarshalErr(&v93v1, h, t, "enc-map-v93-p")
+		v93v2 = nil
+		testUnmarshalErr(&v93v2, bs93, h, t, "dec-map-v93-p-nil")
+		testDeepEqualErr(v93v1, v93v2, t, "equal-map-v93-p-nil")
+		// ...
+		if v == nil {
+			v93v2 = nil
+		} else {
+			v93v2 = make(map[uint8]string, len(v))
+		} // reset map
+		var v93v3, v93v4 typMapMapUint8String
+		v93v3 = typMapMapUint8String(v93v1)
+		v93v4 = typMapMapUint8String(v93v2)
+		bs93 = testMarshalErr(v93v3, h, t, "enc-map-v93-custom")
+		testUnmarshalErr(v93v4, bs93, h, t, "dec-map-v93-p-len")
+		testDeepEqualErr(v93v3, v93v4, t, "equal-map-v93-p-len")
+	}
+
+	for _, v := range []map[uint8]uint{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v94: %v\n", v)
+		var v94v1, v94v2 map[uint8]uint
+		v94v1 = v
+		bs94 := testMarshalErr(v94v1, h, t, "enc-map-v94")
+		if v == nil {
+			v94v2 = nil
+		} else {
+			v94v2 = make(map[uint8]uint, len(v))
+		} // reset map
+		testUnmarshalErr(v94v2, bs94, h, t, "dec-map-v94")
+		testDeepEqualErr(v94v1, v94v2, t, "equal-map-v94")
+		if v == nil {
+			v94v2 = nil
+		} else {
+			v94v2 = make(map[uint8]uint, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v94v2), bs94, h, t, "dec-map-v94-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v94v1, v94v2, t, "equal-map-v94-noaddr")
+		if v == nil {
+			v94v2 = nil
+		} else {
+			v94v2 = make(map[uint8]uint, len(v))
+		} // reset map
+		testUnmarshalErr(&v94v2, bs94, h, t, "dec-map-v94-p-len")
+		testDeepEqualErr(v94v1, v94v2, t, "equal-map-v94-p-len")
+		bs94 = testMarshalErr(&v94v1, h, t, "enc-map-v94-p")
+		v94v2 = nil
+		testUnmarshalErr(&v94v2, bs94, h, t, "dec-map-v94-p-nil")
+		testDeepEqualErr(v94v1, v94v2, t, "equal-map-v94-p-nil")
+		// ...
+		if v == nil {
+			v94v2 = nil
+		} else {
+			v94v2 = make(map[uint8]uint, len(v))
+		} // reset map
+		var v94v3, v94v4 typMapMapUint8Uint
+		v94v3 = typMapMapUint8Uint(v94v1)
+		v94v4 = typMapMapUint8Uint(v94v2)
+		bs94 = testMarshalErr(v94v3, h, t, "enc-map-v94-custom")
+		testUnmarshalErr(v94v4, bs94, h, t, "dec-map-v94-p-len")
+		testDeepEqualErr(v94v3, v94v4, t, "equal-map-v94-p-len")
+	}
+
+	for _, v := range []map[uint8]uint8{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v95: %v\n", v)
+		var v95v1, v95v2 map[uint8]uint8
+		v95v1 = v
+		bs95 := testMarshalErr(v95v1, h, t, "enc-map-v95")
+		if v == nil {
+			v95v2 = nil
+		} else {
+			v95v2 = make(map[uint8]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(v95v2, bs95, h, t, "dec-map-v95")
+		testDeepEqualErr(v95v1, v95v2, t, "equal-map-v95")
+		if v == nil {
+			v95v2 = nil
+		} else {
+			v95v2 = make(map[uint8]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v95v2), bs95, h, t, "dec-map-v95-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v95v1, v95v2, t, "equal-map-v95-noaddr")
+		if v == nil {
+			v95v2 = nil
+		} else {
+			v95v2 = make(map[uint8]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(&v95v2, bs95, h, t, "dec-map-v95-p-len")
+		testDeepEqualErr(v95v1, v95v2, t, "equal-map-v95-p-len")
+		bs95 = testMarshalErr(&v95v1, h, t, "enc-map-v95-p")
+		v95v2 = nil
+		testUnmarshalErr(&v95v2, bs95, h, t, "dec-map-v95-p-nil")
+		testDeepEqualErr(v95v1, v95v2, t, "equal-map-v95-p-nil")
+		// ...
+		if v == nil {
+			v95v2 = nil
+		} else {
+			v95v2 = make(map[uint8]uint8, len(v))
+		} // reset map
+		var v95v3, v95v4 typMapMapUint8Uint8
+		v95v3 = typMapMapUint8Uint8(v95v1)
+		v95v4 = typMapMapUint8Uint8(v95v2)
+		bs95 = testMarshalErr(v95v3, h, t, "enc-map-v95-custom")
+		testUnmarshalErr(v95v4, bs95, h, t, "dec-map-v95-p-len")
+		testDeepEqualErr(v95v3, v95v4, t, "equal-map-v95-p-len")
+	}
+
+	for _, v := range []map[uint8]uint16{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v96: %v\n", v)
+		var v96v1, v96v2 map[uint8]uint16
+		v96v1 = v
+		bs96 := testMarshalErr(v96v1, h, t, "enc-map-v96")
+		if v == nil {
+			v96v2 = nil
+		} else {
+			v96v2 = make(map[uint8]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(v96v2, bs96, h, t, "dec-map-v96")
+		testDeepEqualErr(v96v1, v96v2, t, "equal-map-v96")
+		if v == nil {
+			v96v2 = nil
+		} else {
+			v96v2 = make(map[uint8]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v96v2), bs96, h, t, "dec-map-v96-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v96v1, v96v2, t, "equal-map-v96-noaddr")
+		if v == nil {
+			v96v2 = nil
+		} else {
+			v96v2 = make(map[uint8]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(&v96v2, bs96, h, t, "dec-map-v96-p-len")
+		testDeepEqualErr(v96v1, v96v2, t, "equal-map-v96-p-len")
+		bs96 = testMarshalErr(&v96v1, h, t, "enc-map-v96-p")
+		v96v2 = nil
+		testUnmarshalErr(&v96v2, bs96, h, t, "dec-map-v96-p-nil")
+		testDeepEqualErr(v96v1, v96v2, t, "equal-map-v96-p-nil")
+		// ...
+		if v == nil {
+			v96v2 = nil
+		} else {
+			v96v2 = make(map[uint8]uint16, len(v))
+		} // reset map
+		var v96v3, v96v4 typMapMapUint8Uint16
+		v96v3 = typMapMapUint8Uint16(v96v1)
+		v96v4 = typMapMapUint8Uint16(v96v2)
+		bs96 = testMarshalErr(v96v3, h, t, "enc-map-v96-custom")
+		testUnmarshalErr(v96v4, bs96, h, t, "dec-map-v96-p-len")
+		testDeepEqualErr(v96v3, v96v4, t, "equal-map-v96-p-len")
+	}
+
+	for _, v := range []map[uint8]uint32{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v97: %v\n", v)
+		var v97v1, v97v2 map[uint8]uint32
+		v97v1 = v
+		bs97 := testMarshalErr(v97v1, h, t, "enc-map-v97")
+		if v == nil {
+			v97v2 = nil
+		} else {
+			v97v2 = make(map[uint8]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(v97v2, bs97, h, t, "dec-map-v97")
+		testDeepEqualErr(v97v1, v97v2, t, "equal-map-v97")
+		if v == nil {
+			v97v2 = nil
+		} else {
+			v97v2 = make(map[uint8]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v97v2), bs97, h, t, "dec-map-v97-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v97v1, v97v2, t, "equal-map-v97-noaddr")
+		if v == nil {
+			v97v2 = nil
+		} else {
+			v97v2 = make(map[uint8]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(&v97v2, bs97, h, t, "dec-map-v97-p-len")
+		testDeepEqualErr(v97v1, v97v2, t, "equal-map-v97-p-len")
+		bs97 = testMarshalErr(&v97v1, h, t, "enc-map-v97-p")
+		v97v2 = nil
+		testUnmarshalErr(&v97v2, bs97, h, t, "dec-map-v97-p-nil")
+		testDeepEqualErr(v97v1, v97v2, t, "equal-map-v97-p-nil")
+		// ...
+		if v == nil {
+			v97v2 = nil
+		} else {
+			v97v2 = make(map[uint8]uint32, len(v))
+		} // reset map
+		var v97v3, v97v4 typMapMapUint8Uint32
+		v97v3 = typMapMapUint8Uint32(v97v1)
+		v97v4 = typMapMapUint8Uint32(v97v2)
+		bs97 = testMarshalErr(v97v3, h, t, "enc-map-v97-custom")
+		testUnmarshalErr(v97v4, bs97, h, t, "dec-map-v97-p-len")
+		testDeepEqualErr(v97v3, v97v4, t, "equal-map-v97-p-len")
+	}
+
+	for _, v := range []map[uint8]uint64{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v98: %v\n", v)
+		var v98v1, v98v2 map[uint8]uint64
+		v98v1 = v
+		bs98 := testMarshalErr(v98v1, h, t, "enc-map-v98")
+		if v == nil {
+			v98v2 = nil
+		} else {
+			v98v2 = make(map[uint8]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(v98v2, bs98, h, t, "dec-map-v98")
+		testDeepEqualErr(v98v1, v98v2, t, "equal-map-v98")
+		if v == nil {
+			v98v2 = nil
+		} else {
+			v98v2 = make(map[uint8]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v98v2), bs98, h, t, "dec-map-v98-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v98v1, v98v2, t, "equal-map-v98-noaddr")
+		if v == nil {
+			v98v2 = nil
+		} else {
+			v98v2 = make(map[uint8]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(&v98v2, bs98, h, t, "dec-map-v98-p-len")
+		testDeepEqualErr(v98v1, v98v2, t, "equal-map-v98-p-len")
+		bs98 = testMarshalErr(&v98v1, h, t, "enc-map-v98-p")
+		v98v2 = nil
+		testUnmarshalErr(&v98v2, bs98, h, t, "dec-map-v98-p-nil")
+		testDeepEqualErr(v98v1, v98v2, t, "equal-map-v98-p-nil")
+		// ...
+		if v == nil {
+			v98v2 = nil
+		} else {
+			v98v2 = make(map[uint8]uint64, len(v))
+		} // reset map
+		var v98v3, v98v4 typMapMapUint8Uint64
+		v98v3 = typMapMapUint8Uint64(v98v1)
+		v98v4 = typMapMapUint8Uint64(v98v2)
+		bs98 = testMarshalErr(v98v3, h, t, "enc-map-v98-custom")
+		testUnmarshalErr(v98v4, bs98, h, t, "dec-map-v98-p-len")
+		testDeepEqualErr(v98v3, v98v4, t, "equal-map-v98-p-len")
+	}
+
+	for _, v := range []map[uint8]uintptr{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v99: %v\n", v)
+		var v99v1, v99v2 map[uint8]uintptr
+		v99v1 = v
+		bs99 := testMarshalErr(v99v1, h, t, "enc-map-v99")
+		if v == nil {
+			v99v2 = nil
+		} else {
+			v99v2 = make(map[uint8]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(v99v2, bs99, h, t, "dec-map-v99")
+		testDeepEqualErr(v99v1, v99v2, t, "equal-map-v99")
+		if v == nil {
+			v99v2 = nil
+		} else {
+			v99v2 = make(map[uint8]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v99v2), bs99, h, t, "dec-map-v99-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v99v1, v99v2, t, "equal-map-v99-noaddr")
+		if v == nil {
+			v99v2 = nil
+		} else {
+			v99v2 = make(map[uint8]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(&v99v2, bs99, h, t, "dec-map-v99-p-len")
+		testDeepEqualErr(v99v1, v99v2, t, "equal-map-v99-p-len")
+		bs99 = testMarshalErr(&v99v1, h, t, "enc-map-v99-p")
+		v99v2 = nil
+		testUnmarshalErr(&v99v2, bs99, h, t, "dec-map-v99-p-nil")
+		testDeepEqualErr(v99v1, v99v2, t, "equal-map-v99-p-nil")
+		// ...
+		if v == nil {
+			v99v2 = nil
+		} else {
+			v99v2 = make(map[uint8]uintptr, len(v))
+		} // reset map
+		var v99v3, v99v4 typMapMapUint8Uintptr
+		v99v3 = typMapMapUint8Uintptr(v99v1)
+		v99v4 = typMapMapUint8Uintptr(v99v2)
+		bs99 = testMarshalErr(v99v3, h, t, "enc-map-v99-custom")
+		testUnmarshalErr(v99v4, bs99, h, t, "dec-map-v99-p-len")
+		testDeepEqualErr(v99v3, v99v4, t, "equal-map-v99-p-len")
+	}
+
+	for _, v := range []map[uint8]int{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v100: %v\n", v)
+		var v100v1, v100v2 map[uint8]int
+		v100v1 = v
+		bs100 := testMarshalErr(v100v1, h, t, "enc-map-v100")
+		if v == nil {
+			v100v2 = nil
+		} else {
+			v100v2 = make(map[uint8]int, len(v))
+		} // reset map
+		testUnmarshalErr(v100v2, bs100, h, t, "dec-map-v100")
+		testDeepEqualErr(v100v1, v100v2, t, "equal-map-v100")
+		if v == nil {
+			v100v2 = nil
+		} else {
+			v100v2 = make(map[uint8]int, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v100v2), bs100, h, t, "dec-map-v100-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v100v1, v100v2, t, "equal-map-v100-noaddr")
+		if v == nil {
+			v100v2 = nil
+		} else {
+			v100v2 = make(map[uint8]int, len(v))
+		} // reset map
+		testUnmarshalErr(&v100v2, bs100, h, t, "dec-map-v100-p-len")
+		testDeepEqualErr(v100v1, v100v2, t, "equal-map-v100-p-len")
+		bs100 = testMarshalErr(&v100v1, h, t, "enc-map-v100-p")
+		v100v2 = nil
+		testUnmarshalErr(&v100v2, bs100, h, t, "dec-map-v100-p-nil")
+		testDeepEqualErr(v100v1, v100v2, t, "equal-map-v100-p-nil")
+		// ...
+		if v == nil {
+			v100v2 = nil
+		} else {
+			v100v2 = make(map[uint8]int, len(v))
+		} // reset map
+		var v100v3, v100v4 typMapMapUint8Int
+		v100v3 = typMapMapUint8Int(v100v1)
+		v100v4 = typMapMapUint8Int(v100v2)
+		bs100 = testMarshalErr(v100v3, h, t, "enc-map-v100-custom")
+		testUnmarshalErr(v100v4, bs100, h, t, "dec-map-v100-p-len")
+		testDeepEqualErr(v100v3, v100v4, t, "equal-map-v100-p-len")
+	}
+
+	for _, v := range []map[uint8]int8{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v101: %v\n", v)
+		var v101v1, v101v2 map[uint8]int8
+		v101v1 = v
+		bs101 := testMarshalErr(v101v1, h, t, "enc-map-v101")
+		if v == nil {
+			v101v2 = nil
+		} else {
+			v101v2 = make(map[uint8]int8, len(v))
+		} // reset map
+		testUnmarshalErr(v101v2, bs101, h, t, "dec-map-v101")
+		testDeepEqualErr(v101v1, v101v2, t, "equal-map-v101")
+		if v == nil {
+			v101v2 = nil
+		} else {
+			v101v2 = make(map[uint8]int8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v101v2), bs101, h, t, "dec-map-v101-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v101v1, v101v2, t, "equal-map-v101-noaddr")
+		if v == nil {
+			v101v2 = nil
+		} else {
+			v101v2 = make(map[uint8]int8, len(v))
+		} // reset map
+		testUnmarshalErr(&v101v2, bs101, h, t, "dec-map-v101-p-len")
+		testDeepEqualErr(v101v1, v101v2, t, "equal-map-v101-p-len")
+		bs101 = testMarshalErr(&v101v1, h, t, "enc-map-v101-p")
+		v101v2 = nil
+		testUnmarshalErr(&v101v2, bs101, h, t, "dec-map-v101-p-nil")
+		testDeepEqualErr(v101v1, v101v2, t, "equal-map-v101-p-nil")
+		// ...
+		if v == nil {
+			v101v2 = nil
+		} else {
+			v101v2 = make(map[uint8]int8, len(v))
+		} // reset map
+		var v101v3, v101v4 typMapMapUint8Int8
+		v101v3 = typMapMapUint8Int8(v101v1)
+		v101v4 = typMapMapUint8Int8(v101v2)
+		bs101 = testMarshalErr(v101v3, h, t, "enc-map-v101-custom")
+		testUnmarshalErr(v101v4, bs101, h, t, "dec-map-v101-p-len")
+		testDeepEqualErr(v101v3, v101v4, t, "equal-map-v101-p-len")
+	}
+
+	for _, v := range []map[uint8]int16{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v102: %v\n", v)
+		var v102v1, v102v2 map[uint8]int16
+		v102v1 = v
+		bs102 := testMarshalErr(v102v1, h, t, "enc-map-v102")
+		if v == nil {
+			v102v2 = nil
+		} else {
+			v102v2 = make(map[uint8]int16, len(v))
+		} // reset map
+		testUnmarshalErr(v102v2, bs102, h, t, "dec-map-v102")
+		testDeepEqualErr(v102v1, v102v2, t, "equal-map-v102")
+		if v == nil {
+			v102v2 = nil
+		} else {
+			v102v2 = make(map[uint8]int16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v102v2), bs102, h, t, "dec-map-v102-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v102v1, v102v2, t, "equal-map-v102-noaddr")
+		if v == nil {
+			v102v2 = nil
+		} else {
+			v102v2 = make(map[uint8]int16, len(v))
+		} // reset map
+		testUnmarshalErr(&v102v2, bs102, h, t, "dec-map-v102-p-len")
+		testDeepEqualErr(v102v1, v102v2, t, "equal-map-v102-p-len")
+		bs102 = testMarshalErr(&v102v1, h, t, "enc-map-v102-p")
+		v102v2 = nil
+		testUnmarshalErr(&v102v2, bs102, h, t, "dec-map-v102-p-nil")
+		testDeepEqualErr(v102v1, v102v2, t, "equal-map-v102-p-nil")
+		// ...
+		if v == nil {
+			v102v2 = nil
+		} else {
+			v102v2 = make(map[uint8]int16, len(v))
+		} // reset map
+		var v102v3, v102v4 typMapMapUint8Int16
+		v102v3 = typMapMapUint8Int16(v102v1)
+		v102v4 = typMapMapUint8Int16(v102v2)
+		bs102 = testMarshalErr(v102v3, h, t, "enc-map-v102-custom")
+		testUnmarshalErr(v102v4, bs102, h, t, "dec-map-v102-p-len")
+		testDeepEqualErr(v102v3, v102v4, t, "equal-map-v102-p-len")
+	}
+
+	for _, v := range []map[uint8]int32{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v103: %v\n", v)
+		var v103v1, v103v2 map[uint8]int32
+		v103v1 = v
+		bs103 := testMarshalErr(v103v1, h, t, "enc-map-v103")
+		if v == nil {
+			v103v2 = nil
+		} else {
+			v103v2 = make(map[uint8]int32, len(v))
+		} // reset map
+		testUnmarshalErr(v103v2, bs103, h, t, "dec-map-v103")
+		testDeepEqualErr(v103v1, v103v2, t, "equal-map-v103")
+		if v == nil {
+			v103v2 = nil
+		} else {
+			v103v2 = make(map[uint8]int32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v103v2), bs103, h, t, "dec-map-v103-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v103v1, v103v2, t, "equal-map-v103-noaddr")
+		if v == nil {
+			v103v2 = nil
+		} else {
+			v103v2 = make(map[uint8]int32, len(v))
+		} // reset map
+		testUnmarshalErr(&v103v2, bs103, h, t, "dec-map-v103-p-len")
+		testDeepEqualErr(v103v1, v103v2, t, "equal-map-v103-p-len")
+		bs103 = testMarshalErr(&v103v1, h, t, "enc-map-v103-p")
+		v103v2 = nil
+		testUnmarshalErr(&v103v2, bs103, h, t, "dec-map-v103-p-nil")
+		testDeepEqualErr(v103v1, v103v2, t, "equal-map-v103-p-nil")
+		// ...
+		if v == nil {
+			v103v2 = nil
+		} else {
+			v103v2 = make(map[uint8]int32, len(v))
+		} // reset map
+		var v103v3, v103v4 typMapMapUint8Int32
+		v103v3 = typMapMapUint8Int32(v103v1)
+		v103v4 = typMapMapUint8Int32(v103v2)
+		bs103 = testMarshalErr(v103v3, h, t, "enc-map-v103-custom")
+		testUnmarshalErr(v103v4, bs103, h, t, "dec-map-v103-p-len")
+		testDeepEqualErr(v103v3, v103v4, t, "equal-map-v103-p-len")
+	}
+
+	for _, v := range []map[uint8]int64{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v104: %v\n", v)
+		var v104v1, v104v2 map[uint8]int64
+		v104v1 = v
+		bs104 := testMarshalErr(v104v1, h, t, "enc-map-v104")
+		if v == nil {
+			v104v2 = nil
+		} else {
+			v104v2 = make(map[uint8]int64, len(v))
+		} // reset map
+		testUnmarshalErr(v104v2, bs104, h, t, "dec-map-v104")
+		testDeepEqualErr(v104v1, v104v2, t, "equal-map-v104")
+		if v == nil {
+			v104v2 = nil
+		} else {
+			v104v2 = make(map[uint8]int64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v104v2), bs104, h, t, "dec-map-v104-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v104v1, v104v2, t, "equal-map-v104-noaddr")
+		if v == nil {
+			v104v2 = nil
+		} else {
+			v104v2 = make(map[uint8]int64, len(v))
+		} // reset map
+		testUnmarshalErr(&v104v2, bs104, h, t, "dec-map-v104-p-len")
+		testDeepEqualErr(v104v1, v104v2, t, "equal-map-v104-p-len")
+		bs104 = testMarshalErr(&v104v1, h, t, "enc-map-v104-p")
+		v104v2 = nil
+		testUnmarshalErr(&v104v2, bs104, h, t, "dec-map-v104-p-nil")
+		testDeepEqualErr(v104v1, v104v2, t, "equal-map-v104-p-nil")
+		// ...
+		if v == nil {
+			v104v2 = nil
+		} else {
+			v104v2 = make(map[uint8]int64, len(v))
+		} // reset map
+		var v104v3, v104v4 typMapMapUint8Int64
+		v104v3 = typMapMapUint8Int64(v104v1)
+		v104v4 = typMapMapUint8Int64(v104v2)
+		bs104 = testMarshalErr(v104v3, h, t, "enc-map-v104-custom")
+		testUnmarshalErr(v104v4, bs104, h, t, "dec-map-v104-p-len")
+		testDeepEqualErr(v104v3, v104v4, t, "equal-map-v104-p-len")
+	}
+
+	for _, v := range []map[uint8]float32{nil, {}, {44: 0, 33: 22.2}} {
+		// fmt.Printf(">>>> running mammoth map v105: %v\n", v)
+		var v105v1, v105v2 map[uint8]float32
+		v105v1 = v
+		bs105 := testMarshalErr(v105v1, h, t, "enc-map-v105")
+		if v == nil {
+			v105v2 = nil
+		} else {
+			v105v2 = make(map[uint8]float32, len(v))
+		} // reset map
+		testUnmarshalErr(v105v2, bs105, h, t, "dec-map-v105")
+		testDeepEqualErr(v105v1, v105v2, t, "equal-map-v105")
+		if v == nil {
+			v105v2 = nil
+		} else {
+			v105v2 = make(map[uint8]float32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v105v2), bs105, h, t, "dec-map-v105-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v105v1, v105v2, t, "equal-map-v105-noaddr")
+		if v == nil {
+			v105v2 = nil
+		} else {
+			v105v2 = make(map[uint8]float32, len(v))
+		} // reset map
+		testUnmarshalErr(&v105v2, bs105, h, t, "dec-map-v105-p-len")
+		testDeepEqualErr(v105v1, v105v2, t, "equal-map-v105-p-len")
+		bs105 = testMarshalErr(&v105v1, h, t, "enc-map-v105-p")
+		v105v2 = nil
+		testUnmarshalErr(&v105v2, bs105, h, t, "dec-map-v105-p-nil")
+		testDeepEqualErr(v105v1, v105v2, t, "equal-map-v105-p-nil")
+		// ...
+		if v == nil {
+			v105v2 = nil
+		} else {
+			v105v2 = make(map[uint8]float32, len(v))
+		} // reset map
+		var v105v3, v105v4 typMapMapUint8Float32
+		v105v3 = typMapMapUint8Float32(v105v1)
+		v105v4 = typMapMapUint8Float32(v105v2)
+		bs105 = testMarshalErr(v105v3, h, t, "enc-map-v105-custom")
+		testUnmarshalErr(v105v4, bs105, h, t, "dec-map-v105-p-len")
+		testDeepEqualErr(v105v3, v105v4, t, "equal-map-v105-p-len")
+	}
+
+	for _, v := range []map[uint8]float64{nil, {}, {44: 0, 33: 11.1}} {
+		// fmt.Printf(">>>> running mammoth map v106: %v\n", v)
+		var v106v1, v106v2 map[uint8]float64
+		v106v1 = v
+		bs106 := testMarshalErr(v106v1, h, t, "enc-map-v106")
+		if v == nil {
+			v106v2 = nil
+		} else {
+			v106v2 = make(map[uint8]float64, len(v))
+		} // reset map
+		testUnmarshalErr(v106v2, bs106, h, t, "dec-map-v106")
+		testDeepEqualErr(v106v1, v106v2, t, "equal-map-v106")
+		if v == nil {
+			v106v2 = nil
+		} else {
+			v106v2 = make(map[uint8]float64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v106v2), bs106, h, t, "dec-map-v106-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v106v1, v106v2, t, "equal-map-v106-noaddr")
+		if v == nil {
+			v106v2 = nil
+		} else {
+			v106v2 = make(map[uint8]float64, len(v))
+		} // reset map
+		testUnmarshalErr(&v106v2, bs106, h, t, "dec-map-v106-p-len")
+		testDeepEqualErr(v106v1, v106v2, t, "equal-map-v106-p-len")
+		bs106 = testMarshalErr(&v106v1, h, t, "enc-map-v106-p")
+		v106v2 = nil
+		testUnmarshalErr(&v106v2, bs106, h, t, "dec-map-v106-p-nil")
+		testDeepEqualErr(v106v1, v106v2, t, "equal-map-v106-p-nil")
+		// ...
+		if v == nil {
+			v106v2 = nil
+		} else {
+			v106v2 = make(map[uint8]float64, len(v))
+		} // reset map
+		var v106v3, v106v4 typMapMapUint8Float64
+		v106v3 = typMapMapUint8Float64(v106v1)
+		v106v4 = typMapMapUint8Float64(v106v2)
+		bs106 = testMarshalErr(v106v3, h, t, "enc-map-v106-custom")
+		testUnmarshalErr(v106v4, bs106, h, t, "dec-map-v106-p-len")
+		testDeepEqualErr(v106v3, v106v4, t, "equal-map-v106-p-len")
+	}
+
+	for _, v := range []map[uint8]bool{nil, {}, {44: false, 33: true}} {
+		// fmt.Printf(">>>> running mammoth map v107: %v\n", v)
+		var v107v1, v107v2 map[uint8]bool
+		v107v1 = v
+		bs107 := testMarshalErr(v107v1, h, t, "enc-map-v107")
+		if v == nil {
+			v107v2 = nil
+		} else {
+			v107v2 = make(map[uint8]bool, len(v))
+		} // reset map
+		testUnmarshalErr(v107v2, bs107, h, t, "dec-map-v107")
+		testDeepEqualErr(v107v1, v107v2, t, "equal-map-v107")
+		if v == nil {
+			v107v2 = nil
+		} else {
+			v107v2 = make(map[uint8]bool, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v107v2), bs107, h, t, "dec-map-v107-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v107v1, v107v2, t, "equal-map-v107-noaddr")
+		if v == nil {
+			v107v2 = nil
+		} else {
+			v107v2 = make(map[uint8]bool, len(v))
+		} // reset map
+		testUnmarshalErr(&v107v2, bs107, h, t, "dec-map-v107-p-len")
+		testDeepEqualErr(v107v1, v107v2, t, "equal-map-v107-p-len")
+		bs107 = testMarshalErr(&v107v1, h, t, "enc-map-v107-p")
+		v107v2 = nil
+		testUnmarshalErr(&v107v2, bs107, h, t, "dec-map-v107-p-nil")
+		testDeepEqualErr(v107v1, v107v2, t, "equal-map-v107-p-nil")
+		// ...
+		if v == nil {
+			v107v2 = nil
+		} else {
+			v107v2 = make(map[uint8]bool, len(v))
+		} // reset map
+		var v107v3, v107v4 typMapMapUint8Bool
+		v107v3 = typMapMapUint8Bool(v107v1)
+		v107v4 = typMapMapUint8Bool(v107v2)
+		bs107 = testMarshalErr(v107v3, h, t, "enc-map-v107-custom")
+		testUnmarshalErr(v107v4, bs107, h, t, "dec-map-v107-p-len")
+		testDeepEqualErr(v107v3, v107v4, t, "equal-map-v107-p-len")
+	}
+
+	for _, v := range []map[uint16]interface{}{nil, {}, {44: nil, 33: "string-is-an-interface-2"}} {
+		// fmt.Printf(">>>> running mammoth map v110: %v\n", v)
+		var v110v1, v110v2 map[uint16]interface{}
+		v110v1 = v
+		bs110 := testMarshalErr(v110v1, h, t, "enc-map-v110")
+		if v == nil {
+			v110v2 = nil
+		} else {
+			v110v2 = make(map[uint16]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(v110v2, bs110, h, t, "dec-map-v110")
+		testDeepEqualErr(v110v1, v110v2, t, "equal-map-v110")
+		if v == nil {
+			v110v2 = nil
+		} else {
+			v110v2 = make(map[uint16]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v110v2), bs110, h, t, "dec-map-v110-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v110v1, v110v2, t, "equal-map-v110-noaddr")
+		if v == nil {
+			v110v2 = nil
+		} else {
+			v110v2 = make(map[uint16]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(&v110v2, bs110, h, t, "dec-map-v110-p-len")
+		testDeepEqualErr(v110v1, v110v2, t, "equal-map-v110-p-len")
+		bs110 = testMarshalErr(&v110v1, h, t, "enc-map-v110-p")
+		v110v2 = nil
+		testUnmarshalErr(&v110v2, bs110, h, t, "dec-map-v110-p-nil")
+		testDeepEqualErr(v110v1, v110v2, t, "equal-map-v110-p-nil")
+		// ...
+		if v == nil {
+			v110v2 = nil
+		} else {
+			v110v2 = make(map[uint16]interface{}, len(v))
+		} // reset map
+		var v110v3, v110v4 typMapMapUint16Intf
+		v110v3 = typMapMapUint16Intf(v110v1)
+		v110v4 = typMapMapUint16Intf(v110v2)
+		bs110 = testMarshalErr(v110v3, h, t, "enc-map-v110-custom")
+		testUnmarshalErr(v110v4, bs110, h, t, "dec-map-v110-p-len")
+		testDeepEqualErr(v110v3, v110v4, t, "equal-map-v110-p-len")
+	}
+
+	for _, v := range []map[uint16]string{nil, {}, {44: "", 33: "some-string-2"}} {
+		// fmt.Printf(">>>> running mammoth map v111: %v\n", v)
+		var v111v1, v111v2 map[uint16]string
+		v111v1 = v
+		bs111 := testMarshalErr(v111v1, h, t, "enc-map-v111")
+		if v == nil {
+			v111v2 = nil
+		} else {
+			v111v2 = make(map[uint16]string, len(v))
+		} // reset map
+		testUnmarshalErr(v111v2, bs111, h, t, "dec-map-v111")
+		testDeepEqualErr(v111v1, v111v2, t, "equal-map-v111")
+		if v == nil {
+			v111v2 = nil
+		} else {
+			v111v2 = make(map[uint16]string, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v111v2), bs111, h, t, "dec-map-v111-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v111v1, v111v2, t, "equal-map-v111-noaddr")
+		if v == nil {
+			v111v2 = nil
+		} else {
+			v111v2 = make(map[uint16]string, len(v))
+		} // reset map
+		testUnmarshalErr(&v111v2, bs111, h, t, "dec-map-v111-p-len")
+		testDeepEqualErr(v111v1, v111v2, t, "equal-map-v111-p-len")
+		bs111 = testMarshalErr(&v111v1, h, t, "enc-map-v111-p")
+		v111v2 = nil
+		testUnmarshalErr(&v111v2, bs111, h, t, "dec-map-v111-p-nil")
+		testDeepEqualErr(v111v1, v111v2, t, "equal-map-v111-p-nil")
+		// ...
+		if v == nil {
+			v111v2 = nil
+		} else {
+			v111v2 = make(map[uint16]string, len(v))
+		} // reset map
+		var v111v3, v111v4 typMapMapUint16String
+		v111v3 = typMapMapUint16String(v111v1)
+		v111v4 = typMapMapUint16String(v111v2)
+		bs111 = testMarshalErr(v111v3, h, t, "enc-map-v111-custom")
+		testUnmarshalErr(v111v4, bs111, h, t, "dec-map-v111-p-len")
+		testDeepEqualErr(v111v3, v111v4, t, "equal-map-v111-p-len")
+	}
+
+	for _, v := range []map[uint16]uint{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v112: %v\n", v)
+		var v112v1, v112v2 map[uint16]uint
+		v112v1 = v
+		bs112 := testMarshalErr(v112v1, h, t, "enc-map-v112")
+		if v == nil {
+			v112v2 = nil
+		} else {
+			v112v2 = make(map[uint16]uint, len(v))
+		} // reset map
+		testUnmarshalErr(v112v2, bs112, h, t, "dec-map-v112")
+		testDeepEqualErr(v112v1, v112v2, t, "equal-map-v112")
+		if v == nil {
+			v112v2 = nil
+		} else {
+			v112v2 = make(map[uint16]uint, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v112v2), bs112, h, t, "dec-map-v112-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v112v1, v112v2, t, "equal-map-v112-noaddr")
+		if v == nil {
+			v112v2 = nil
+		} else {
+			v112v2 = make(map[uint16]uint, len(v))
+		} // reset map
+		testUnmarshalErr(&v112v2, bs112, h, t, "dec-map-v112-p-len")
+		testDeepEqualErr(v112v1, v112v2, t, "equal-map-v112-p-len")
+		bs112 = testMarshalErr(&v112v1, h, t, "enc-map-v112-p")
+		v112v2 = nil
+		testUnmarshalErr(&v112v2, bs112, h, t, "dec-map-v112-p-nil")
+		testDeepEqualErr(v112v1, v112v2, t, "equal-map-v112-p-nil")
+		// ...
+		if v == nil {
+			v112v2 = nil
+		} else {
+			v112v2 = make(map[uint16]uint, len(v))
+		} // reset map
+		var v112v3, v112v4 typMapMapUint16Uint
+		v112v3 = typMapMapUint16Uint(v112v1)
+		v112v4 = typMapMapUint16Uint(v112v2)
+		bs112 = testMarshalErr(v112v3, h, t, "enc-map-v112-custom")
+		testUnmarshalErr(v112v4, bs112, h, t, "dec-map-v112-p-len")
+		testDeepEqualErr(v112v3, v112v4, t, "equal-map-v112-p-len")
+	}
+
+	for _, v := range []map[uint16]uint8{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v113: %v\n", v)
+		var v113v1, v113v2 map[uint16]uint8
+		v113v1 = v
+		bs113 := testMarshalErr(v113v1, h, t, "enc-map-v113")
+		if v == nil {
+			v113v2 = nil
+		} else {
+			v113v2 = make(map[uint16]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(v113v2, bs113, h, t, "dec-map-v113")
+		testDeepEqualErr(v113v1, v113v2, t, "equal-map-v113")
+		if v == nil {
+			v113v2 = nil
+		} else {
+			v113v2 = make(map[uint16]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v113v2), bs113, h, t, "dec-map-v113-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v113v1, v113v2, t, "equal-map-v113-noaddr")
+		if v == nil {
+			v113v2 = nil
+		} else {
+			v113v2 = make(map[uint16]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(&v113v2, bs113, h, t, "dec-map-v113-p-len")
+		testDeepEqualErr(v113v1, v113v2, t, "equal-map-v113-p-len")
+		bs113 = testMarshalErr(&v113v1, h, t, "enc-map-v113-p")
+		v113v2 = nil
+		testUnmarshalErr(&v113v2, bs113, h, t, "dec-map-v113-p-nil")
+		testDeepEqualErr(v113v1, v113v2, t, "equal-map-v113-p-nil")
+		// ...
+		if v == nil {
+			v113v2 = nil
+		} else {
+			v113v2 = make(map[uint16]uint8, len(v))
+		} // reset map
+		var v113v3, v113v4 typMapMapUint16Uint8
+		v113v3 = typMapMapUint16Uint8(v113v1)
+		v113v4 = typMapMapUint16Uint8(v113v2)
+		bs113 = testMarshalErr(v113v3, h, t, "enc-map-v113-custom")
+		testUnmarshalErr(v113v4, bs113, h, t, "dec-map-v113-p-len")
+		testDeepEqualErr(v113v3, v113v4, t, "equal-map-v113-p-len")
+	}
+
+	for _, v := range []map[uint16]uint16{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v114: %v\n", v)
+		var v114v1, v114v2 map[uint16]uint16
+		v114v1 = v
+		bs114 := testMarshalErr(v114v1, h, t, "enc-map-v114")
+		if v == nil {
+			v114v2 = nil
+		} else {
+			v114v2 = make(map[uint16]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(v114v2, bs114, h, t, "dec-map-v114")
+		testDeepEqualErr(v114v1, v114v2, t, "equal-map-v114")
+		if v == nil {
+			v114v2 = nil
+		} else {
+			v114v2 = make(map[uint16]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v114v2), bs114, h, t, "dec-map-v114-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v114v1, v114v2, t, "equal-map-v114-noaddr")
+		if v == nil {
+			v114v2 = nil
+		} else {
+			v114v2 = make(map[uint16]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(&v114v2, bs114, h, t, "dec-map-v114-p-len")
+		testDeepEqualErr(v114v1, v114v2, t, "equal-map-v114-p-len")
+		bs114 = testMarshalErr(&v114v1, h, t, "enc-map-v114-p")
+		v114v2 = nil
+		testUnmarshalErr(&v114v2, bs114, h, t, "dec-map-v114-p-nil")
+		testDeepEqualErr(v114v1, v114v2, t, "equal-map-v114-p-nil")
+		// ...
+		if v == nil {
+			v114v2 = nil
+		} else {
+			v114v2 = make(map[uint16]uint16, len(v))
+		} // reset map
+		var v114v3, v114v4 typMapMapUint16Uint16
+		v114v3 = typMapMapUint16Uint16(v114v1)
+		v114v4 = typMapMapUint16Uint16(v114v2)
+		bs114 = testMarshalErr(v114v3, h, t, "enc-map-v114-custom")
+		testUnmarshalErr(v114v4, bs114, h, t, "dec-map-v114-p-len")
+		testDeepEqualErr(v114v3, v114v4, t, "equal-map-v114-p-len")
+	}
+
+	for _, v := range []map[uint16]uint32{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v115: %v\n", v)
+		var v115v1, v115v2 map[uint16]uint32
+		v115v1 = v
+		bs115 := testMarshalErr(v115v1, h, t, "enc-map-v115")
+		if v == nil {
+			v115v2 = nil
+		} else {
+			v115v2 = make(map[uint16]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(v115v2, bs115, h, t, "dec-map-v115")
+		testDeepEqualErr(v115v1, v115v2, t, "equal-map-v115")
+		if v == nil {
+			v115v2 = nil
+		} else {
+			v115v2 = make(map[uint16]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v115v2), bs115, h, t, "dec-map-v115-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v115v1, v115v2, t, "equal-map-v115-noaddr")
+		if v == nil {
+			v115v2 = nil
+		} else {
+			v115v2 = make(map[uint16]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(&v115v2, bs115, h, t, "dec-map-v115-p-len")
+		testDeepEqualErr(v115v1, v115v2, t, "equal-map-v115-p-len")
+		bs115 = testMarshalErr(&v115v1, h, t, "enc-map-v115-p")
+		v115v2 = nil
+		testUnmarshalErr(&v115v2, bs115, h, t, "dec-map-v115-p-nil")
+		testDeepEqualErr(v115v1, v115v2, t, "equal-map-v115-p-nil")
+		// ...
+		if v == nil {
+			v115v2 = nil
+		} else {
+			v115v2 = make(map[uint16]uint32, len(v))
+		} // reset map
+		var v115v3, v115v4 typMapMapUint16Uint32
+		v115v3 = typMapMapUint16Uint32(v115v1)
+		v115v4 = typMapMapUint16Uint32(v115v2)
+		bs115 = testMarshalErr(v115v3, h, t, "enc-map-v115-custom")
+		testUnmarshalErr(v115v4, bs115, h, t, "dec-map-v115-p-len")
+		testDeepEqualErr(v115v3, v115v4, t, "equal-map-v115-p-len")
+	}
+
+	for _, v := range []map[uint16]uint64{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v116: %v\n", v)
+		var v116v1, v116v2 map[uint16]uint64
+		v116v1 = v
+		bs116 := testMarshalErr(v116v1, h, t, "enc-map-v116")
+		if v == nil {
+			v116v2 = nil
+		} else {
+			v116v2 = make(map[uint16]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(v116v2, bs116, h, t, "dec-map-v116")
+		testDeepEqualErr(v116v1, v116v2, t, "equal-map-v116")
+		if v == nil {
+			v116v2 = nil
+		} else {
+			v116v2 = make(map[uint16]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v116v2), bs116, h, t, "dec-map-v116-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v116v1, v116v2, t, "equal-map-v116-noaddr")
+		if v == nil {
+			v116v2 = nil
+		} else {
+			v116v2 = make(map[uint16]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(&v116v2, bs116, h, t, "dec-map-v116-p-len")
+		testDeepEqualErr(v116v1, v116v2, t, "equal-map-v116-p-len")
+		bs116 = testMarshalErr(&v116v1, h, t, "enc-map-v116-p")
+		v116v2 = nil
+		testUnmarshalErr(&v116v2, bs116, h, t, "dec-map-v116-p-nil")
+		testDeepEqualErr(v116v1, v116v2, t, "equal-map-v116-p-nil")
+		// ...
+		if v == nil {
+			v116v2 = nil
+		} else {
+			v116v2 = make(map[uint16]uint64, len(v))
+		} // reset map
+		var v116v3, v116v4 typMapMapUint16Uint64
+		v116v3 = typMapMapUint16Uint64(v116v1)
+		v116v4 = typMapMapUint16Uint64(v116v2)
+		bs116 = testMarshalErr(v116v3, h, t, "enc-map-v116-custom")
+		testUnmarshalErr(v116v4, bs116, h, t, "dec-map-v116-p-len")
+		testDeepEqualErr(v116v3, v116v4, t, "equal-map-v116-p-len")
+	}
+
+	for _, v := range []map[uint16]uintptr{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v117: %v\n", v)
+		var v117v1, v117v2 map[uint16]uintptr
+		v117v1 = v
+		bs117 := testMarshalErr(v117v1, h, t, "enc-map-v117")
+		if v == nil {
+			v117v2 = nil
+		} else {
+			v117v2 = make(map[uint16]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(v117v2, bs117, h, t, "dec-map-v117")
+		testDeepEqualErr(v117v1, v117v2, t, "equal-map-v117")
+		if v == nil {
+			v117v2 = nil
+		} else {
+			v117v2 = make(map[uint16]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v117v2), bs117, h, t, "dec-map-v117-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v117v1, v117v2, t, "equal-map-v117-noaddr")
+		if v == nil {
+			v117v2 = nil
+		} else {
+			v117v2 = make(map[uint16]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(&v117v2, bs117, h, t, "dec-map-v117-p-len")
+		testDeepEqualErr(v117v1, v117v2, t, "equal-map-v117-p-len")
+		bs117 = testMarshalErr(&v117v1, h, t, "enc-map-v117-p")
+		v117v2 = nil
+		testUnmarshalErr(&v117v2, bs117, h, t, "dec-map-v117-p-nil")
+		testDeepEqualErr(v117v1, v117v2, t, "equal-map-v117-p-nil")
+		// ...
+		if v == nil {
+			v117v2 = nil
+		} else {
+			v117v2 = make(map[uint16]uintptr, len(v))
+		} // reset map
+		var v117v3, v117v4 typMapMapUint16Uintptr
+		v117v3 = typMapMapUint16Uintptr(v117v1)
+		v117v4 = typMapMapUint16Uintptr(v117v2)
+		bs117 = testMarshalErr(v117v3, h, t, "enc-map-v117-custom")
+		testUnmarshalErr(v117v4, bs117, h, t, "dec-map-v117-p-len")
+		testDeepEqualErr(v117v3, v117v4, t, "equal-map-v117-p-len")
+	}
+
+	for _, v := range []map[uint16]int{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v118: %v\n", v)
+		var v118v1, v118v2 map[uint16]int
+		v118v1 = v
+		bs118 := testMarshalErr(v118v1, h, t, "enc-map-v118")
+		if v == nil {
+			v118v2 = nil
+		} else {
+			v118v2 = make(map[uint16]int, len(v))
+		} // reset map
+		testUnmarshalErr(v118v2, bs118, h, t, "dec-map-v118")
+		testDeepEqualErr(v118v1, v118v2, t, "equal-map-v118")
+		if v == nil {
+			v118v2 = nil
+		} else {
+			v118v2 = make(map[uint16]int, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v118v2), bs118, h, t, "dec-map-v118-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v118v1, v118v2, t, "equal-map-v118-noaddr")
+		if v == nil {
+			v118v2 = nil
+		} else {
+			v118v2 = make(map[uint16]int, len(v))
+		} // reset map
+		testUnmarshalErr(&v118v2, bs118, h, t, "dec-map-v118-p-len")
+		testDeepEqualErr(v118v1, v118v2, t, "equal-map-v118-p-len")
+		bs118 = testMarshalErr(&v118v1, h, t, "enc-map-v118-p")
+		v118v2 = nil
+		testUnmarshalErr(&v118v2, bs118, h, t, "dec-map-v118-p-nil")
+		testDeepEqualErr(v118v1, v118v2, t, "equal-map-v118-p-nil")
+		// ...
+		if v == nil {
+			v118v2 = nil
+		} else {
+			v118v2 = make(map[uint16]int, len(v))
+		} // reset map
+		var v118v3, v118v4 typMapMapUint16Int
+		v118v3 = typMapMapUint16Int(v118v1)
+		v118v4 = typMapMapUint16Int(v118v2)
+		bs118 = testMarshalErr(v118v3, h, t, "enc-map-v118-custom")
+		testUnmarshalErr(v118v4, bs118, h, t, "dec-map-v118-p-len")
+		testDeepEqualErr(v118v3, v118v4, t, "equal-map-v118-p-len")
+	}
+
+	for _, v := range []map[uint16]int8{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v119: %v\n", v)
+		var v119v1, v119v2 map[uint16]int8
+		v119v1 = v
+		bs119 := testMarshalErr(v119v1, h, t, "enc-map-v119")
+		if v == nil {
+			v119v2 = nil
+		} else {
+			v119v2 = make(map[uint16]int8, len(v))
+		} // reset map
+		testUnmarshalErr(v119v2, bs119, h, t, "dec-map-v119")
+		testDeepEqualErr(v119v1, v119v2, t, "equal-map-v119")
+		if v == nil {
+			v119v2 = nil
+		} else {
+			v119v2 = make(map[uint16]int8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v119v2), bs119, h, t, "dec-map-v119-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v119v1, v119v2, t, "equal-map-v119-noaddr")
+		if v == nil {
+			v119v2 = nil
+		} else {
+			v119v2 = make(map[uint16]int8, len(v))
+		} // reset map
+		testUnmarshalErr(&v119v2, bs119, h, t, "dec-map-v119-p-len")
+		testDeepEqualErr(v119v1, v119v2, t, "equal-map-v119-p-len")
+		bs119 = testMarshalErr(&v119v1, h, t, "enc-map-v119-p")
+		v119v2 = nil
+		testUnmarshalErr(&v119v2, bs119, h, t, "dec-map-v119-p-nil")
+		testDeepEqualErr(v119v1, v119v2, t, "equal-map-v119-p-nil")
+		// ...
+		if v == nil {
+			v119v2 = nil
+		} else {
+			v119v2 = make(map[uint16]int8, len(v))
+		} // reset map
+		var v119v3, v119v4 typMapMapUint16Int8
+		v119v3 = typMapMapUint16Int8(v119v1)
+		v119v4 = typMapMapUint16Int8(v119v2)
+		bs119 = testMarshalErr(v119v3, h, t, "enc-map-v119-custom")
+		testUnmarshalErr(v119v4, bs119, h, t, "dec-map-v119-p-len")
+		testDeepEqualErr(v119v3, v119v4, t, "equal-map-v119-p-len")
+	}
+
+	for _, v := range []map[uint16]int16{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v120: %v\n", v)
+		var v120v1, v120v2 map[uint16]int16
+		v120v1 = v
+		bs120 := testMarshalErr(v120v1, h, t, "enc-map-v120")
+		if v == nil {
+			v120v2 = nil
+		} else {
+			v120v2 = make(map[uint16]int16, len(v))
+		} // reset map
+		testUnmarshalErr(v120v2, bs120, h, t, "dec-map-v120")
+		testDeepEqualErr(v120v1, v120v2, t, "equal-map-v120")
+		if v == nil {
+			v120v2 = nil
+		} else {
+			v120v2 = make(map[uint16]int16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v120v2), bs120, h, t, "dec-map-v120-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v120v1, v120v2, t, "equal-map-v120-noaddr")
+		if v == nil {
+			v120v2 = nil
+		} else {
+			v120v2 = make(map[uint16]int16, len(v))
+		} // reset map
+		testUnmarshalErr(&v120v2, bs120, h, t, "dec-map-v120-p-len")
+		testDeepEqualErr(v120v1, v120v2, t, "equal-map-v120-p-len")
+		bs120 = testMarshalErr(&v120v1, h, t, "enc-map-v120-p")
+		v120v2 = nil
+		testUnmarshalErr(&v120v2, bs120, h, t, "dec-map-v120-p-nil")
+		testDeepEqualErr(v120v1, v120v2, t, "equal-map-v120-p-nil")
+		// ...
+		if v == nil {
+			v120v2 = nil
+		} else {
+			v120v2 = make(map[uint16]int16, len(v))
+		} // reset map
+		var v120v3, v120v4 typMapMapUint16Int16
+		v120v3 = typMapMapUint16Int16(v120v1)
+		v120v4 = typMapMapUint16Int16(v120v2)
+		bs120 = testMarshalErr(v120v3, h, t, "enc-map-v120-custom")
+		testUnmarshalErr(v120v4, bs120, h, t, "dec-map-v120-p-len")
+		testDeepEqualErr(v120v3, v120v4, t, "equal-map-v120-p-len")
+	}
+
+	for _, v := range []map[uint16]int32{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v121: %v\n", v)
+		var v121v1, v121v2 map[uint16]int32
+		v121v1 = v
+		bs121 := testMarshalErr(v121v1, h, t, "enc-map-v121")
+		if v == nil {
+			v121v2 = nil
+		} else {
+			v121v2 = make(map[uint16]int32, len(v))
+		} // reset map
+		testUnmarshalErr(v121v2, bs121, h, t, "dec-map-v121")
+		testDeepEqualErr(v121v1, v121v2, t, "equal-map-v121")
+		if v == nil {
+			v121v2 = nil
+		} else {
+			v121v2 = make(map[uint16]int32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v121v2), bs121, h, t, "dec-map-v121-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v121v1, v121v2, t, "equal-map-v121-noaddr")
+		if v == nil {
+			v121v2 = nil
+		} else {
+			v121v2 = make(map[uint16]int32, len(v))
+		} // reset map
+		testUnmarshalErr(&v121v2, bs121, h, t, "dec-map-v121-p-len")
+		testDeepEqualErr(v121v1, v121v2, t, "equal-map-v121-p-len")
+		bs121 = testMarshalErr(&v121v1, h, t, "enc-map-v121-p")
+		v121v2 = nil
+		testUnmarshalErr(&v121v2, bs121, h, t, "dec-map-v121-p-nil")
+		testDeepEqualErr(v121v1, v121v2, t, "equal-map-v121-p-nil")
+		// ...
+		if v == nil {
+			v121v2 = nil
+		} else {
+			v121v2 = make(map[uint16]int32, len(v))
+		} // reset map
+		var v121v3, v121v4 typMapMapUint16Int32
+		v121v3 = typMapMapUint16Int32(v121v1)
+		v121v4 = typMapMapUint16Int32(v121v2)
+		bs121 = testMarshalErr(v121v3, h, t, "enc-map-v121-custom")
+		testUnmarshalErr(v121v4, bs121, h, t, "dec-map-v121-p-len")
+		testDeepEqualErr(v121v3, v121v4, t, "equal-map-v121-p-len")
+	}
+
+	for _, v := range []map[uint16]int64{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v122: %v\n", v)
+		var v122v1, v122v2 map[uint16]int64
+		v122v1 = v
+		bs122 := testMarshalErr(v122v1, h, t, "enc-map-v122")
+		if v == nil {
+			v122v2 = nil
+		} else {
+			v122v2 = make(map[uint16]int64, len(v))
+		} // reset map
+		testUnmarshalErr(v122v2, bs122, h, t, "dec-map-v122")
+		testDeepEqualErr(v122v1, v122v2, t, "equal-map-v122")
+		if v == nil {
+			v122v2 = nil
+		} else {
+			v122v2 = make(map[uint16]int64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v122v2), bs122, h, t, "dec-map-v122-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v122v1, v122v2, t, "equal-map-v122-noaddr")
+		if v == nil {
+			v122v2 = nil
+		} else {
+			v122v2 = make(map[uint16]int64, len(v))
+		} // reset map
+		testUnmarshalErr(&v122v2, bs122, h, t, "dec-map-v122-p-len")
+		testDeepEqualErr(v122v1, v122v2, t, "equal-map-v122-p-len")
+		bs122 = testMarshalErr(&v122v1, h, t, "enc-map-v122-p")
+		v122v2 = nil
+		testUnmarshalErr(&v122v2, bs122, h, t, "dec-map-v122-p-nil")
+		testDeepEqualErr(v122v1, v122v2, t, "equal-map-v122-p-nil")
+		// ...
+		if v == nil {
+			v122v2 = nil
+		} else {
+			v122v2 = make(map[uint16]int64, len(v))
+		} // reset map
+		var v122v3, v122v4 typMapMapUint16Int64
+		v122v3 = typMapMapUint16Int64(v122v1)
+		v122v4 = typMapMapUint16Int64(v122v2)
+		bs122 = testMarshalErr(v122v3, h, t, "enc-map-v122-custom")
+		testUnmarshalErr(v122v4, bs122, h, t, "dec-map-v122-p-len")
+		testDeepEqualErr(v122v3, v122v4, t, "equal-map-v122-p-len")
+	}
+
+	for _, v := range []map[uint16]float32{nil, {}, {33: 0, 44: 22.2}} {
+		// fmt.Printf(">>>> running mammoth map v123: %v\n", v)
+		var v123v1, v123v2 map[uint16]float32
+		v123v1 = v
+		bs123 := testMarshalErr(v123v1, h, t, "enc-map-v123")
+		if v == nil {
+			v123v2 = nil
+		} else {
+			v123v2 = make(map[uint16]float32, len(v))
+		} // reset map
+		testUnmarshalErr(v123v2, bs123, h, t, "dec-map-v123")
+		testDeepEqualErr(v123v1, v123v2, t, "equal-map-v123")
+		if v == nil {
+			v123v2 = nil
+		} else {
+			v123v2 = make(map[uint16]float32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v123v2), bs123, h, t, "dec-map-v123-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v123v1, v123v2, t, "equal-map-v123-noaddr")
+		if v == nil {
+			v123v2 = nil
+		} else {
+			v123v2 = make(map[uint16]float32, len(v))
+		} // reset map
+		testUnmarshalErr(&v123v2, bs123, h, t, "dec-map-v123-p-len")
+		testDeepEqualErr(v123v1, v123v2, t, "equal-map-v123-p-len")
+		bs123 = testMarshalErr(&v123v1, h, t, "enc-map-v123-p")
+		v123v2 = nil
+		testUnmarshalErr(&v123v2, bs123, h, t, "dec-map-v123-p-nil")
+		testDeepEqualErr(v123v1, v123v2, t, "equal-map-v123-p-nil")
+		// ...
+		if v == nil {
+			v123v2 = nil
+		} else {
+			v123v2 = make(map[uint16]float32, len(v))
+		} // reset map
+		var v123v3, v123v4 typMapMapUint16Float32
+		v123v3 = typMapMapUint16Float32(v123v1)
+		v123v4 = typMapMapUint16Float32(v123v2)
+		bs123 = testMarshalErr(v123v3, h, t, "enc-map-v123-custom")
+		testUnmarshalErr(v123v4, bs123, h, t, "dec-map-v123-p-len")
+		testDeepEqualErr(v123v3, v123v4, t, "equal-map-v123-p-len")
+	}
+
+	for _, v := range []map[uint16]float64{nil, {}, {33: 0, 44: 11.1}} {
+		// fmt.Printf(">>>> running mammoth map v124: %v\n", v)
+		var v124v1, v124v2 map[uint16]float64
+		v124v1 = v
+		bs124 := testMarshalErr(v124v1, h, t, "enc-map-v124")
+		if v == nil {
+			v124v2 = nil
+		} else {
+			v124v2 = make(map[uint16]float64, len(v))
+		} // reset map
+		testUnmarshalErr(v124v2, bs124, h, t, "dec-map-v124")
+		testDeepEqualErr(v124v1, v124v2, t, "equal-map-v124")
+		if v == nil {
+			v124v2 = nil
+		} else {
+			v124v2 = make(map[uint16]float64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v124v2), bs124, h, t, "dec-map-v124-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v124v1, v124v2, t, "equal-map-v124-noaddr")
+		if v == nil {
+			v124v2 = nil
+		} else {
+			v124v2 = make(map[uint16]float64, len(v))
+		} // reset map
+		testUnmarshalErr(&v124v2, bs124, h, t, "dec-map-v124-p-len")
+		testDeepEqualErr(v124v1, v124v2, t, "equal-map-v124-p-len")
+		bs124 = testMarshalErr(&v124v1, h, t, "enc-map-v124-p")
+		v124v2 = nil
+		testUnmarshalErr(&v124v2, bs124, h, t, "dec-map-v124-p-nil")
+		testDeepEqualErr(v124v1, v124v2, t, "equal-map-v124-p-nil")
+		// ...
+		if v == nil {
+			v124v2 = nil
+		} else {
+			v124v2 = make(map[uint16]float64, len(v))
+		} // reset map
+		var v124v3, v124v4 typMapMapUint16Float64
+		v124v3 = typMapMapUint16Float64(v124v1)
+		v124v4 = typMapMapUint16Float64(v124v2)
+		bs124 = testMarshalErr(v124v3, h, t, "enc-map-v124-custom")
+		testUnmarshalErr(v124v4, bs124, h, t, "dec-map-v124-p-len")
+		testDeepEqualErr(v124v3, v124v4, t, "equal-map-v124-p-len")
+	}
+
+	for _, v := range []map[uint16]bool{nil, {}, {33: false, 44: true}} {
+		// fmt.Printf(">>>> running mammoth map v125: %v\n", v)
+		var v125v1, v125v2 map[uint16]bool
+		v125v1 = v
+		bs125 := testMarshalErr(v125v1, h, t, "enc-map-v125")
+		if v == nil {
+			v125v2 = nil
+		} else {
+			v125v2 = make(map[uint16]bool, len(v))
+		} // reset map
+		testUnmarshalErr(v125v2, bs125, h, t, "dec-map-v125")
+		testDeepEqualErr(v125v1, v125v2, t, "equal-map-v125")
+		if v == nil {
+			v125v2 = nil
+		} else {
+			v125v2 = make(map[uint16]bool, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v125v2), bs125, h, t, "dec-map-v125-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v125v1, v125v2, t, "equal-map-v125-noaddr")
+		if v == nil {
+			v125v2 = nil
+		} else {
+			v125v2 = make(map[uint16]bool, len(v))
+		} // reset map
+		testUnmarshalErr(&v125v2, bs125, h, t, "dec-map-v125-p-len")
+		testDeepEqualErr(v125v1, v125v2, t, "equal-map-v125-p-len")
+		bs125 = testMarshalErr(&v125v1, h, t, "enc-map-v125-p")
+		v125v2 = nil
+		testUnmarshalErr(&v125v2, bs125, h, t, "dec-map-v125-p-nil")
+		testDeepEqualErr(v125v1, v125v2, t, "equal-map-v125-p-nil")
+		// ...
+		if v == nil {
+			v125v2 = nil
+		} else {
+			v125v2 = make(map[uint16]bool, len(v))
+		} // reset map
+		var v125v3, v125v4 typMapMapUint16Bool
+		v125v3 = typMapMapUint16Bool(v125v1)
+		v125v4 = typMapMapUint16Bool(v125v2)
+		bs125 = testMarshalErr(v125v3, h, t, "enc-map-v125-custom")
+		testUnmarshalErr(v125v4, bs125, h, t, "dec-map-v125-p-len")
+		testDeepEqualErr(v125v3, v125v4, t, "equal-map-v125-p-len")
+	}
+
+	for _, v := range []map[uint32]interface{}{nil, {}, {33: nil, 44: "string-is-an-interface"}} {
+		// fmt.Printf(">>>> running mammoth map v128: %v\n", v)
+		var v128v1, v128v2 map[uint32]interface{}
+		v128v1 = v
+		bs128 := testMarshalErr(v128v1, h, t, "enc-map-v128")
+		if v == nil {
+			v128v2 = nil
+		} else {
+			v128v2 = make(map[uint32]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(v128v2, bs128, h, t, "dec-map-v128")
+		testDeepEqualErr(v128v1, v128v2, t, "equal-map-v128")
+		if v == nil {
+			v128v2 = nil
+		} else {
+			v128v2 = make(map[uint32]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v128v2), bs128, h, t, "dec-map-v128-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v128v1, v128v2, t, "equal-map-v128-noaddr")
+		if v == nil {
+			v128v2 = nil
+		} else {
+			v128v2 = make(map[uint32]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(&v128v2, bs128, h, t, "dec-map-v128-p-len")
+		testDeepEqualErr(v128v1, v128v2, t, "equal-map-v128-p-len")
+		bs128 = testMarshalErr(&v128v1, h, t, "enc-map-v128-p")
+		v128v2 = nil
+		testUnmarshalErr(&v128v2, bs128, h, t, "dec-map-v128-p-nil")
+		testDeepEqualErr(v128v1, v128v2, t, "equal-map-v128-p-nil")
+		// ...
+		if v == nil {
+			v128v2 = nil
+		} else {
+			v128v2 = make(map[uint32]interface{}, len(v))
+		} // reset map
+		var v128v3, v128v4 typMapMapUint32Intf
+		v128v3 = typMapMapUint32Intf(v128v1)
+		v128v4 = typMapMapUint32Intf(v128v2)
+		bs128 = testMarshalErr(v128v3, h, t, "enc-map-v128-custom")
+		testUnmarshalErr(v128v4, bs128, h, t, "dec-map-v128-p-len")
+		testDeepEqualErr(v128v3, v128v4, t, "equal-map-v128-p-len")
+	}
+
+	for _, v := range []map[uint32]string{nil, {}, {33: "", 44: "some-string"}} {
+		// fmt.Printf(">>>> running mammoth map v129: %v\n", v)
+		var v129v1, v129v2 map[uint32]string
+		v129v1 = v
+		bs129 := testMarshalErr(v129v1, h, t, "enc-map-v129")
+		if v == nil {
+			v129v2 = nil
+		} else {
+			v129v2 = make(map[uint32]string, len(v))
+		} // reset map
+		testUnmarshalErr(v129v2, bs129, h, t, "dec-map-v129")
+		testDeepEqualErr(v129v1, v129v2, t, "equal-map-v129")
+		if v == nil {
+			v129v2 = nil
+		} else {
+			v129v2 = make(map[uint32]string, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v129v2), bs129, h, t, "dec-map-v129-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v129v1, v129v2, t, "equal-map-v129-noaddr")
+		if v == nil {
+			v129v2 = nil
+		} else {
+			v129v2 = make(map[uint32]string, len(v))
+		} // reset map
+		testUnmarshalErr(&v129v2, bs129, h, t, "dec-map-v129-p-len")
+		testDeepEqualErr(v129v1, v129v2, t, "equal-map-v129-p-len")
+		bs129 = testMarshalErr(&v129v1, h, t, "enc-map-v129-p")
+		v129v2 = nil
+		testUnmarshalErr(&v129v2, bs129, h, t, "dec-map-v129-p-nil")
+		testDeepEqualErr(v129v1, v129v2, t, "equal-map-v129-p-nil")
+		// ...
+		if v == nil {
+			v129v2 = nil
+		} else {
+			v129v2 = make(map[uint32]string, len(v))
+		} // reset map
+		var v129v3, v129v4 typMapMapUint32String
+		v129v3 = typMapMapUint32String(v129v1)
+		v129v4 = typMapMapUint32String(v129v2)
+		bs129 = testMarshalErr(v129v3, h, t, "enc-map-v129-custom")
+		testUnmarshalErr(v129v4, bs129, h, t, "dec-map-v129-p-len")
+		testDeepEqualErr(v129v3, v129v4, t, "equal-map-v129-p-len")
+	}
+
+	for _, v := range []map[uint32]uint{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v130: %v\n", v)
+		var v130v1, v130v2 map[uint32]uint
+		v130v1 = v
+		bs130 := testMarshalErr(v130v1, h, t, "enc-map-v130")
+		if v == nil {
+			v130v2 = nil
+		} else {
+			v130v2 = make(map[uint32]uint, len(v))
+		} // reset map
+		testUnmarshalErr(v130v2, bs130, h, t, "dec-map-v130")
+		testDeepEqualErr(v130v1, v130v2, t, "equal-map-v130")
+		if v == nil {
+			v130v2 = nil
+		} else {
+			v130v2 = make(map[uint32]uint, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v130v2), bs130, h, t, "dec-map-v130-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v130v1, v130v2, t, "equal-map-v130-noaddr")
+		if v == nil {
+			v130v2 = nil
+		} else {
+			v130v2 = make(map[uint32]uint, len(v))
+		} // reset map
+		testUnmarshalErr(&v130v2, bs130, h, t, "dec-map-v130-p-len")
+		testDeepEqualErr(v130v1, v130v2, t, "equal-map-v130-p-len")
+		bs130 = testMarshalErr(&v130v1, h, t, "enc-map-v130-p")
+		v130v2 = nil
+		testUnmarshalErr(&v130v2, bs130, h, t, "dec-map-v130-p-nil")
+		testDeepEqualErr(v130v1, v130v2, t, "equal-map-v130-p-nil")
+		// ...
+		if v == nil {
+			v130v2 = nil
+		} else {
+			v130v2 = make(map[uint32]uint, len(v))
+		} // reset map
+		var v130v3, v130v4 typMapMapUint32Uint
+		v130v3 = typMapMapUint32Uint(v130v1)
+		v130v4 = typMapMapUint32Uint(v130v2)
+		bs130 = testMarshalErr(v130v3, h, t, "enc-map-v130-custom")
+		testUnmarshalErr(v130v4, bs130, h, t, "dec-map-v130-p-len")
+		testDeepEqualErr(v130v3, v130v4, t, "equal-map-v130-p-len")
+	}
+
+	for _, v := range []map[uint32]uint8{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v131: %v\n", v)
+		var v131v1, v131v2 map[uint32]uint8
+		v131v1 = v
+		bs131 := testMarshalErr(v131v1, h, t, "enc-map-v131")
+		if v == nil {
+			v131v2 = nil
+		} else {
+			v131v2 = make(map[uint32]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(v131v2, bs131, h, t, "dec-map-v131")
+		testDeepEqualErr(v131v1, v131v2, t, "equal-map-v131")
+		if v == nil {
+			v131v2 = nil
+		} else {
+			v131v2 = make(map[uint32]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v131v2), bs131, h, t, "dec-map-v131-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v131v1, v131v2, t, "equal-map-v131-noaddr")
+		if v == nil {
+			v131v2 = nil
+		} else {
+			v131v2 = make(map[uint32]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(&v131v2, bs131, h, t, "dec-map-v131-p-len")
+		testDeepEqualErr(v131v1, v131v2, t, "equal-map-v131-p-len")
+		bs131 = testMarshalErr(&v131v1, h, t, "enc-map-v131-p")
+		v131v2 = nil
+		testUnmarshalErr(&v131v2, bs131, h, t, "dec-map-v131-p-nil")
+		testDeepEqualErr(v131v1, v131v2, t, "equal-map-v131-p-nil")
+		// ...
+		if v == nil {
+			v131v2 = nil
+		} else {
+			v131v2 = make(map[uint32]uint8, len(v))
+		} // reset map
+		var v131v3, v131v4 typMapMapUint32Uint8
+		v131v3 = typMapMapUint32Uint8(v131v1)
+		v131v4 = typMapMapUint32Uint8(v131v2)
+		bs131 = testMarshalErr(v131v3, h, t, "enc-map-v131-custom")
+		testUnmarshalErr(v131v4, bs131, h, t, "dec-map-v131-p-len")
+		testDeepEqualErr(v131v3, v131v4, t, "equal-map-v131-p-len")
+	}
+
+	for _, v := range []map[uint32]uint16{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v132: %v\n", v)
+		var v132v1, v132v2 map[uint32]uint16
+		v132v1 = v
+		bs132 := testMarshalErr(v132v1, h, t, "enc-map-v132")
+		if v == nil {
+			v132v2 = nil
+		} else {
+			v132v2 = make(map[uint32]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(v132v2, bs132, h, t, "dec-map-v132")
+		testDeepEqualErr(v132v1, v132v2, t, "equal-map-v132")
+		if v == nil {
+			v132v2 = nil
+		} else {
+			v132v2 = make(map[uint32]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v132v2), bs132, h, t, "dec-map-v132-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v132v1, v132v2, t, "equal-map-v132-noaddr")
+		if v == nil {
+			v132v2 = nil
+		} else {
+			v132v2 = make(map[uint32]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(&v132v2, bs132, h, t, "dec-map-v132-p-len")
+		testDeepEqualErr(v132v1, v132v2, t, "equal-map-v132-p-len")
+		bs132 = testMarshalErr(&v132v1, h, t, "enc-map-v132-p")
+		v132v2 = nil
+		testUnmarshalErr(&v132v2, bs132, h, t, "dec-map-v132-p-nil")
+		testDeepEqualErr(v132v1, v132v2, t, "equal-map-v132-p-nil")
+		// ...
+		if v == nil {
+			v132v2 = nil
+		} else {
+			v132v2 = make(map[uint32]uint16, len(v))
+		} // reset map
+		var v132v3, v132v4 typMapMapUint32Uint16
+		v132v3 = typMapMapUint32Uint16(v132v1)
+		v132v4 = typMapMapUint32Uint16(v132v2)
+		bs132 = testMarshalErr(v132v3, h, t, "enc-map-v132-custom")
+		testUnmarshalErr(v132v4, bs132, h, t, "dec-map-v132-p-len")
+		testDeepEqualErr(v132v3, v132v4, t, "equal-map-v132-p-len")
+	}
+
+	for _, v := range []map[uint32]uint32{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v133: %v\n", v)
+		var v133v1, v133v2 map[uint32]uint32
+		v133v1 = v
+		bs133 := testMarshalErr(v133v1, h, t, "enc-map-v133")
+		if v == nil {
+			v133v2 = nil
+		} else {
+			v133v2 = make(map[uint32]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(v133v2, bs133, h, t, "dec-map-v133")
+		testDeepEqualErr(v133v1, v133v2, t, "equal-map-v133")
+		if v == nil {
+			v133v2 = nil
+		} else {
+			v133v2 = make(map[uint32]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v133v2), bs133, h, t, "dec-map-v133-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v133v1, v133v2, t, "equal-map-v133-noaddr")
+		if v == nil {
+			v133v2 = nil
+		} else {
+			v133v2 = make(map[uint32]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(&v133v2, bs133, h, t, "dec-map-v133-p-len")
+		testDeepEqualErr(v133v1, v133v2, t, "equal-map-v133-p-len")
+		bs133 = testMarshalErr(&v133v1, h, t, "enc-map-v133-p")
+		v133v2 = nil
+		testUnmarshalErr(&v133v2, bs133, h, t, "dec-map-v133-p-nil")
+		testDeepEqualErr(v133v1, v133v2, t, "equal-map-v133-p-nil")
+		// ...
+		if v == nil {
+			v133v2 = nil
+		} else {
+			v133v2 = make(map[uint32]uint32, len(v))
+		} // reset map
+		var v133v3, v133v4 typMapMapUint32Uint32
+		v133v3 = typMapMapUint32Uint32(v133v1)
+		v133v4 = typMapMapUint32Uint32(v133v2)
+		bs133 = testMarshalErr(v133v3, h, t, "enc-map-v133-custom")
+		testUnmarshalErr(v133v4, bs133, h, t, "dec-map-v133-p-len")
+		testDeepEqualErr(v133v3, v133v4, t, "equal-map-v133-p-len")
+	}
+
+	for _, v := range []map[uint32]uint64{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v134: %v\n", v)
+		var v134v1, v134v2 map[uint32]uint64
+		v134v1 = v
+		bs134 := testMarshalErr(v134v1, h, t, "enc-map-v134")
+		if v == nil {
+			v134v2 = nil
+		} else {
+			v134v2 = make(map[uint32]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(v134v2, bs134, h, t, "dec-map-v134")
+		testDeepEqualErr(v134v1, v134v2, t, "equal-map-v134")
+		if v == nil {
+			v134v2 = nil
+		} else {
+			v134v2 = make(map[uint32]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v134v2), bs134, h, t, "dec-map-v134-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v134v1, v134v2, t, "equal-map-v134-noaddr")
+		if v == nil {
+			v134v2 = nil
+		} else {
+			v134v2 = make(map[uint32]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(&v134v2, bs134, h, t, "dec-map-v134-p-len")
+		testDeepEqualErr(v134v1, v134v2, t, "equal-map-v134-p-len")
+		bs134 = testMarshalErr(&v134v1, h, t, "enc-map-v134-p")
+		v134v2 = nil
+		testUnmarshalErr(&v134v2, bs134, h, t, "dec-map-v134-p-nil")
+		testDeepEqualErr(v134v1, v134v2, t, "equal-map-v134-p-nil")
+		// ...
+		if v == nil {
+			v134v2 = nil
+		} else {
+			v134v2 = make(map[uint32]uint64, len(v))
+		} // reset map
+		var v134v3, v134v4 typMapMapUint32Uint64
+		v134v3 = typMapMapUint32Uint64(v134v1)
+		v134v4 = typMapMapUint32Uint64(v134v2)
+		bs134 = testMarshalErr(v134v3, h, t, "enc-map-v134-custom")
+		testUnmarshalErr(v134v4, bs134, h, t, "dec-map-v134-p-len")
+		testDeepEqualErr(v134v3, v134v4, t, "equal-map-v134-p-len")
+	}
+
+	for _, v := range []map[uint32]uintptr{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v135: %v\n", v)
+		var v135v1, v135v2 map[uint32]uintptr
+		v135v1 = v
+		bs135 := testMarshalErr(v135v1, h, t, "enc-map-v135")
+		if v == nil {
+			v135v2 = nil
+		} else {
+			v135v2 = make(map[uint32]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(v135v2, bs135, h, t, "dec-map-v135")
+		testDeepEqualErr(v135v1, v135v2, t, "equal-map-v135")
+		if v == nil {
+			v135v2 = nil
+		} else {
+			v135v2 = make(map[uint32]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v135v2), bs135, h, t, "dec-map-v135-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v135v1, v135v2, t, "equal-map-v135-noaddr")
+		if v == nil {
+			v135v2 = nil
+		} else {
+			v135v2 = make(map[uint32]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(&v135v2, bs135, h, t, "dec-map-v135-p-len")
+		testDeepEqualErr(v135v1, v135v2, t, "equal-map-v135-p-len")
+		bs135 = testMarshalErr(&v135v1, h, t, "enc-map-v135-p")
+		v135v2 = nil
+		testUnmarshalErr(&v135v2, bs135, h, t, "dec-map-v135-p-nil")
+		testDeepEqualErr(v135v1, v135v2, t, "equal-map-v135-p-nil")
+		// ...
+		if v == nil {
+			v135v2 = nil
+		} else {
+			v135v2 = make(map[uint32]uintptr, len(v))
+		} // reset map
+		var v135v3, v135v4 typMapMapUint32Uintptr
+		v135v3 = typMapMapUint32Uintptr(v135v1)
+		v135v4 = typMapMapUint32Uintptr(v135v2)
+		bs135 = testMarshalErr(v135v3, h, t, "enc-map-v135-custom")
+		testUnmarshalErr(v135v4, bs135, h, t, "dec-map-v135-p-len")
+		testDeepEqualErr(v135v3, v135v4, t, "equal-map-v135-p-len")
+	}
+
+	for _, v := range []map[uint32]int{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v136: %v\n", v)
+		var v136v1, v136v2 map[uint32]int
+		v136v1 = v
+		bs136 := testMarshalErr(v136v1, h, t, "enc-map-v136")
+		if v == nil {
+			v136v2 = nil
+		} else {
+			v136v2 = make(map[uint32]int, len(v))
+		} // reset map
+		testUnmarshalErr(v136v2, bs136, h, t, "dec-map-v136")
+		testDeepEqualErr(v136v1, v136v2, t, "equal-map-v136")
+		if v == nil {
+			v136v2 = nil
+		} else {
+			v136v2 = make(map[uint32]int, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v136v2), bs136, h, t, "dec-map-v136-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v136v1, v136v2, t, "equal-map-v136-noaddr")
+		if v == nil {
+			v136v2 = nil
+		} else {
+			v136v2 = make(map[uint32]int, len(v))
+		} // reset map
+		testUnmarshalErr(&v136v2, bs136, h, t, "dec-map-v136-p-len")
+		testDeepEqualErr(v136v1, v136v2, t, "equal-map-v136-p-len")
+		bs136 = testMarshalErr(&v136v1, h, t, "enc-map-v136-p")
+		v136v2 = nil
+		testUnmarshalErr(&v136v2, bs136, h, t, "dec-map-v136-p-nil")
+		testDeepEqualErr(v136v1, v136v2, t, "equal-map-v136-p-nil")
+		// ...
+		if v == nil {
+			v136v2 = nil
+		} else {
+			v136v2 = make(map[uint32]int, len(v))
+		} // reset map
+		var v136v3, v136v4 typMapMapUint32Int
+		v136v3 = typMapMapUint32Int(v136v1)
+		v136v4 = typMapMapUint32Int(v136v2)
+		bs136 = testMarshalErr(v136v3, h, t, "enc-map-v136-custom")
+		testUnmarshalErr(v136v4, bs136, h, t, "dec-map-v136-p-len")
+		testDeepEqualErr(v136v3, v136v4, t, "equal-map-v136-p-len")
+	}
+
+	for _, v := range []map[uint32]int8{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v137: %v\n", v)
+		var v137v1, v137v2 map[uint32]int8
+		v137v1 = v
+		bs137 := testMarshalErr(v137v1, h, t, "enc-map-v137")
+		if v == nil {
+			v137v2 = nil
+		} else {
+			v137v2 = make(map[uint32]int8, len(v))
+		} // reset map
+		testUnmarshalErr(v137v2, bs137, h, t, "dec-map-v137")
+		testDeepEqualErr(v137v1, v137v2, t, "equal-map-v137")
+		if v == nil {
+			v137v2 = nil
+		} else {
+			v137v2 = make(map[uint32]int8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v137v2), bs137, h, t, "dec-map-v137-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v137v1, v137v2, t, "equal-map-v137-noaddr")
+		if v == nil {
+			v137v2 = nil
+		} else {
+			v137v2 = make(map[uint32]int8, len(v))
+		} // reset map
+		testUnmarshalErr(&v137v2, bs137, h, t, "dec-map-v137-p-len")
+		testDeepEqualErr(v137v1, v137v2, t, "equal-map-v137-p-len")
+		bs137 = testMarshalErr(&v137v1, h, t, "enc-map-v137-p")
+		v137v2 = nil
+		testUnmarshalErr(&v137v2, bs137, h, t, "dec-map-v137-p-nil")
+		testDeepEqualErr(v137v1, v137v2, t, "equal-map-v137-p-nil")
+		// ...
+		if v == nil {
+			v137v2 = nil
+		} else {
+			v137v2 = make(map[uint32]int8, len(v))
+		} // reset map
+		var v137v3, v137v4 typMapMapUint32Int8
+		v137v3 = typMapMapUint32Int8(v137v1)
+		v137v4 = typMapMapUint32Int8(v137v2)
+		bs137 = testMarshalErr(v137v3, h, t, "enc-map-v137-custom")
+		testUnmarshalErr(v137v4, bs137, h, t, "dec-map-v137-p-len")
+		testDeepEqualErr(v137v3, v137v4, t, "equal-map-v137-p-len")
+	}
+
+	for _, v := range []map[uint32]int16{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v138: %v\n", v)
+		var v138v1, v138v2 map[uint32]int16
+		v138v1 = v
+		bs138 := testMarshalErr(v138v1, h, t, "enc-map-v138")
+		if v == nil {
+			v138v2 = nil
+		} else {
+			v138v2 = make(map[uint32]int16, len(v))
+		} // reset map
+		testUnmarshalErr(v138v2, bs138, h, t, "dec-map-v138")
+		testDeepEqualErr(v138v1, v138v2, t, "equal-map-v138")
+		if v == nil {
+			v138v2 = nil
+		} else {
+			v138v2 = make(map[uint32]int16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v138v2), bs138, h, t, "dec-map-v138-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v138v1, v138v2, t, "equal-map-v138-noaddr")
+		if v == nil {
+			v138v2 = nil
+		} else {
+			v138v2 = make(map[uint32]int16, len(v))
+		} // reset map
+		testUnmarshalErr(&v138v2, bs138, h, t, "dec-map-v138-p-len")
+		testDeepEqualErr(v138v1, v138v2, t, "equal-map-v138-p-len")
+		bs138 = testMarshalErr(&v138v1, h, t, "enc-map-v138-p")
+		v138v2 = nil
+		testUnmarshalErr(&v138v2, bs138, h, t, "dec-map-v138-p-nil")
+		testDeepEqualErr(v138v1, v138v2, t, "equal-map-v138-p-nil")
+		// ...
+		if v == nil {
+			v138v2 = nil
+		} else {
+			v138v2 = make(map[uint32]int16, len(v))
+		} // reset map
+		var v138v3, v138v4 typMapMapUint32Int16
+		v138v3 = typMapMapUint32Int16(v138v1)
+		v138v4 = typMapMapUint32Int16(v138v2)
+		bs138 = testMarshalErr(v138v3, h, t, "enc-map-v138-custom")
+		testUnmarshalErr(v138v4, bs138, h, t, "dec-map-v138-p-len")
+		testDeepEqualErr(v138v3, v138v4, t, "equal-map-v138-p-len")
+	}
+
+	for _, v := range []map[uint32]int32{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v139: %v\n", v)
+		var v139v1, v139v2 map[uint32]int32
+		v139v1 = v
+		bs139 := testMarshalErr(v139v1, h, t, "enc-map-v139")
+		if v == nil {
+			v139v2 = nil
+		} else {
+			v139v2 = make(map[uint32]int32, len(v))
+		} // reset map
+		testUnmarshalErr(v139v2, bs139, h, t, "dec-map-v139")
+		testDeepEqualErr(v139v1, v139v2, t, "equal-map-v139")
+		if v == nil {
+			v139v2 = nil
+		} else {
+			v139v2 = make(map[uint32]int32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v139v2), bs139, h, t, "dec-map-v139-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v139v1, v139v2, t, "equal-map-v139-noaddr")
+		if v == nil {
+			v139v2 = nil
+		} else {
+			v139v2 = make(map[uint32]int32, len(v))
+		} // reset map
+		testUnmarshalErr(&v139v2, bs139, h, t, "dec-map-v139-p-len")
+		testDeepEqualErr(v139v1, v139v2, t, "equal-map-v139-p-len")
+		bs139 = testMarshalErr(&v139v1, h, t, "enc-map-v139-p")
+		v139v2 = nil
+		testUnmarshalErr(&v139v2, bs139, h, t, "dec-map-v139-p-nil")
+		testDeepEqualErr(v139v1, v139v2, t, "equal-map-v139-p-nil")
+		// ...
+		if v == nil {
+			v139v2 = nil
+		} else {
+			v139v2 = make(map[uint32]int32, len(v))
+		} // reset map
+		var v139v3, v139v4 typMapMapUint32Int32
+		v139v3 = typMapMapUint32Int32(v139v1)
+		v139v4 = typMapMapUint32Int32(v139v2)
+		bs139 = testMarshalErr(v139v3, h, t, "enc-map-v139-custom")
+		testUnmarshalErr(v139v4, bs139, h, t, "dec-map-v139-p-len")
+		testDeepEqualErr(v139v3, v139v4, t, "equal-map-v139-p-len")
+	}
+
+	for _, v := range []map[uint32]int64{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v140: %v\n", v)
+		var v140v1, v140v2 map[uint32]int64
+		v140v1 = v
+		bs140 := testMarshalErr(v140v1, h, t, "enc-map-v140")
+		if v == nil {
+			v140v2 = nil
+		} else {
+			v140v2 = make(map[uint32]int64, len(v))
+		} // reset map
+		testUnmarshalErr(v140v2, bs140, h, t, "dec-map-v140")
+		testDeepEqualErr(v140v1, v140v2, t, "equal-map-v140")
+		if v == nil {
+			v140v2 = nil
+		} else {
+			v140v2 = make(map[uint32]int64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v140v2), bs140, h, t, "dec-map-v140-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v140v1, v140v2, t, "equal-map-v140-noaddr")
+		if v == nil {
+			v140v2 = nil
+		} else {
+			v140v2 = make(map[uint32]int64, len(v))
+		} // reset map
+		testUnmarshalErr(&v140v2, bs140, h, t, "dec-map-v140-p-len")
+		testDeepEqualErr(v140v1, v140v2, t, "equal-map-v140-p-len")
+		bs140 = testMarshalErr(&v140v1, h, t, "enc-map-v140-p")
+		v140v2 = nil
+		testUnmarshalErr(&v140v2, bs140, h, t, "dec-map-v140-p-nil")
+		testDeepEqualErr(v140v1, v140v2, t, "equal-map-v140-p-nil")
+		// ...
+		if v == nil {
+			v140v2 = nil
+		} else {
+			v140v2 = make(map[uint32]int64, len(v))
+		} // reset map
+		var v140v3, v140v4 typMapMapUint32Int64
+		v140v3 = typMapMapUint32Int64(v140v1)
+		v140v4 = typMapMapUint32Int64(v140v2)
+		bs140 = testMarshalErr(v140v3, h, t, "enc-map-v140-custom")
+		testUnmarshalErr(v140v4, bs140, h, t, "dec-map-v140-p-len")
+		testDeepEqualErr(v140v3, v140v4, t, "equal-map-v140-p-len")
+	}
+
+	for _, v := range []map[uint32]float32{nil, {}, {44: 0, 33: 22.2}} {
+		// fmt.Printf(">>>> running mammoth map v141: %v\n", v)
+		var v141v1, v141v2 map[uint32]float32
+		v141v1 = v
+		bs141 := testMarshalErr(v141v1, h, t, "enc-map-v141")
+		if v == nil {
+			v141v2 = nil
+		} else {
+			v141v2 = make(map[uint32]float32, len(v))
+		} // reset map
+		testUnmarshalErr(v141v2, bs141, h, t, "dec-map-v141")
+		testDeepEqualErr(v141v1, v141v2, t, "equal-map-v141")
+		if v == nil {
+			v141v2 = nil
+		} else {
+			v141v2 = make(map[uint32]float32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v141v2), bs141, h, t, "dec-map-v141-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v141v1, v141v2, t, "equal-map-v141-noaddr")
+		if v == nil {
+			v141v2 = nil
+		} else {
+			v141v2 = make(map[uint32]float32, len(v))
+		} // reset map
+		testUnmarshalErr(&v141v2, bs141, h, t, "dec-map-v141-p-len")
+		testDeepEqualErr(v141v1, v141v2, t, "equal-map-v141-p-len")
+		bs141 = testMarshalErr(&v141v1, h, t, "enc-map-v141-p")
+		v141v2 = nil
+		testUnmarshalErr(&v141v2, bs141, h, t, "dec-map-v141-p-nil")
+		testDeepEqualErr(v141v1, v141v2, t, "equal-map-v141-p-nil")
+		// ...
+		if v == nil {
+			v141v2 = nil
+		} else {
+			v141v2 = make(map[uint32]float32, len(v))
+		} // reset map
+		var v141v3, v141v4 typMapMapUint32Float32
+		v141v3 = typMapMapUint32Float32(v141v1)
+		v141v4 = typMapMapUint32Float32(v141v2)
+		bs141 = testMarshalErr(v141v3, h, t, "enc-map-v141-custom")
+		testUnmarshalErr(v141v4, bs141, h, t, "dec-map-v141-p-len")
+		testDeepEqualErr(v141v3, v141v4, t, "equal-map-v141-p-len")
+	}
+
+	for _, v := range []map[uint32]float64{nil, {}, {44: 0, 33: 11.1}} {
+		// fmt.Printf(">>>> running mammoth map v142: %v\n", v)
+		var v142v1, v142v2 map[uint32]float64
+		v142v1 = v
+		bs142 := testMarshalErr(v142v1, h, t, "enc-map-v142")
+		if v == nil {
+			v142v2 = nil
+		} else {
+			v142v2 = make(map[uint32]float64, len(v))
+		} // reset map
+		testUnmarshalErr(v142v2, bs142, h, t, "dec-map-v142")
+		testDeepEqualErr(v142v1, v142v2, t, "equal-map-v142")
+		if v == nil {
+			v142v2 = nil
+		} else {
+			v142v2 = make(map[uint32]float64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v142v2), bs142, h, t, "dec-map-v142-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v142v1, v142v2, t, "equal-map-v142-noaddr")
+		if v == nil {
+			v142v2 = nil
+		} else {
+			v142v2 = make(map[uint32]float64, len(v))
+		} // reset map
+		testUnmarshalErr(&v142v2, bs142, h, t, "dec-map-v142-p-len")
+		testDeepEqualErr(v142v1, v142v2, t, "equal-map-v142-p-len")
+		bs142 = testMarshalErr(&v142v1, h, t, "enc-map-v142-p")
+		v142v2 = nil
+		testUnmarshalErr(&v142v2, bs142, h, t, "dec-map-v142-p-nil")
+		testDeepEqualErr(v142v1, v142v2, t, "equal-map-v142-p-nil")
+		// ...
+		if v == nil {
+			v142v2 = nil
+		} else {
+			v142v2 = make(map[uint32]float64, len(v))
+		} // reset map
+		var v142v3, v142v4 typMapMapUint32Float64
+		v142v3 = typMapMapUint32Float64(v142v1)
+		v142v4 = typMapMapUint32Float64(v142v2)
+		bs142 = testMarshalErr(v142v3, h, t, "enc-map-v142-custom")
+		testUnmarshalErr(v142v4, bs142, h, t, "dec-map-v142-p-len")
+		testDeepEqualErr(v142v3, v142v4, t, "equal-map-v142-p-len")
+	}
+
+	for _, v := range []map[uint32]bool{nil, {}, {44: false, 33: true}} {
+		// fmt.Printf(">>>> running mammoth map v143: %v\n", v)
+		var v143v1, v143v2 map[uint32]bool
+		v143v1 = v
+		bs143 := testMarshalErr(v143v1, h, t, "enc-map-v143")
+		if v == nil {
+			v143v2 = nil
+		} else {
+			v143v2 = make(map[uint32]bool, len(v))
+		} // reset map
+		testUnmarshalErr(v143v2, bs143, h, t, "dec-map-v143")
+		testDeepEqualErr(v143v1, v143v2, t, "equal-map-v143")
+		if v == nil {
+			v143v2 = nil
+		} else {
+			v143v2 = make(map[uint32]bool, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v143v2), bs143, h, t, "dec-map-v143-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v143v1, v143v2, t, "equal-map-v143-noaddr")
+		if v == nil {
+			v143v2 = nil
+		} else {
+			v143v2 = make(map[uint32]bool, len(v))
+		} // reset map
+		testUnmarshalErr(&v143v2, bs143, h, t, "dec-map-v143-p-len")
+		testDeepEqualErr(v143v1, v143v2, t, "equal-map-v143-p-len")
+		bs143 = testMarshalErr(&v143v1, h, t, "enc-map-v143-p")
+		v143v2 = nil
+		testUnmarshalErr(&v143v2, bs143, h, t, "dec-map-v143-p-nil")
+		testDeepEqualErr(v143v1, v143v2, t, "equal-map-v143-p-nil")
+		// ...
+		if v == nil {
+			v143v2 = nil
+		} else {
+			v143v2 = make(map[uint32]bool, len(v))
+		} // reset map
+		var v143v3, v143v4 typMapMapUint32Bool
+		v143v3 = typMapMapUint32Bool(v143v1)
+		v143v4 = typMapMapUint32Bool(v143v2)
+		bs143 = testMarshalErr(v143v3, h, t, "enc-map-v143-custom")
+		testUnmarshalErr(v143v4, bs143, h, t, "dec-map-v143-p-len")
+		testDeepEqualErr(v143v3, v143v4, t, "equal-map-v143-p-len")
+	}
+
+	for _, v := range []map[uint64]interface{}{nil, {}, {44: nil, 33: "string-is-an-interface-2"}} {
+		// fmt.Printf(">>>> running mammoth map v146: %v\n", v)
+		var v146v1, v146v2 map[uint64]interface{}
+		v146v1 = v
+		bs146 := testMarshalErr(v146v1, h, t, "enc-map-v146")
+		if v == nil {
+			v146v2 = nil
+		} else {
+			v146v2 = make(map[uint64]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(v146v2, bs146, h, t, "dec-map-v146")
+		testDeepEqualErr(v146v1, v146v2, t, "equal-map-v146")
+		if v == nil {
+			v146v2 = nil
+		} else {
+			v146v2 = make(map[uint64]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v146v2), bs146, h, t, "dec-map-v146-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v146v1, v146v2, t, "equal-map-v146-noaddr")
+		if v == nil {
+			v146v2 = nil
+		} else {
+			v146v2 = make(map[uint64]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(&v146v2, bs146, h, t, "dec-map-v146-p-len")
+		testDeepEqualErr(v146v1, v146v2, t, "equal-map-v146-p-len")
+		bs146 = testMarshalErr(&v146v1, h, t, "enc-map-v146-p")
+		v146v2 = nil
+		testUnmarshalErr(&v146v2, bs146, h, t, "dec-map-v146-p-nil")
+		testDeepEqualErr(v146v1, v146v2, t, "equal-map-v146-p-nil")
+		// ...
+		if v == nil {
+			v146v2 = nil
+		} else {
+			v146v2 = make(map[uint64]interface{}, len(v))
+		} // reset map
+		var v146v3, v146v4 typMapMapUint64Intf
+		v146v3 = typMapMapUint64Intf(v146v1)
+		v146v4 = typMapMapUint64Intf(v146v2)
+		bs146 = testMarshalErr(v146v3, h, t, "enc-map-v146-custom")
+		testUnmarshalErr(v146v4, bs146, h, t, "dec-map-v146-p-len")
+		testDeepEqualErr(v146v3, v146v4, t, "equal-map-v146-p-len")
+	}
+
+	for _, v := range []map[uint64]string{nil, {}, {44: "", 33: "some-string-2"}} {
+		// fmt.Printf(">>>> running mammoth map v147: %v\n", v)
+		var v147v1, v147v2 map[uint64]string
+		v147v1 = v
+		bs147 := testMarshalErr(v147v1, h, t, "enc-map-v147")
+		if v == nil {
+			v147v2 = nil
+		} else {
+			v147v2 = make(map[uint64]string, len(v))
+		} // reset map
+		testUnmarshalErr(v147v2, bs147, h, t, "dec-map-v147")
+		testDeepEqualErr(v147v1, v147v2, t, "equal-map-v147")
+		if v == nil {
+			v147v2 = nil
+		} else {
+			v147v2 = make(map[uint64]string, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v147v2), bs147, h, t, "dec-map-v147-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v147v1, v147v2, t, "equal-map-v147-noaddr")
+		if v == nil {
+			v147v2 = nil
+		} else {
+			v147v2 = make(map[uint64]string, len(v))
+		} // reset map
+		testUnmarshalErr(&v147v2, bs147, h, t, "dec-map-v147-p-len")
+		testDeepEqualErr(v147v1, v147v2, t, "equal-map-v147-p-len")
+		bs147 = testMarshalErr(&v147v1, h, t, "enc-map-v147-p")
+		v147v2 = nil
+		testUnmarshalErr(&v147v2, bs147, h, t, "dec-map-v147-p-nil")
+		testDeepEqualErr(v147v1, v147v2, t, "equal-map-v147-p-nil")
+		// ...
+		if v == nil {
+			v147v2 = nil
+		} else {
+			v147v2 = make(map[uint64]string, len(v))
+		} // reset map
+		var v147v3, v147v4 typMapMapUint64String
+		v147v3 = typMapMapUint64String(v147v1)
+		v147v4 = typMapMapUint64String(v147v2)
+		bs147 = testMarshalErr(v147v3, h, t, "enc-map-v147-custom")
+		testUnmarshalErr(v147v4, bs147, h, t, "dec-map-v147-p-len")
+		testDeepEqualErr(v147v3, v147v4, t, "equal-map-v147-p-len")
+	}
+
+	for _, v := range []map[uint64]uint{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v148: %v\n", v)
+		var v148v1, v148v2 map[uint64]uint
+		v148v1 = v
+		bs148 := testMarshalErr(v148v1, h, t, "enc-map-v148")
+		if v == nil {
+			v148v2 = nil
+		} else {
+			v148v2 = make(map[uint64]uint, len(v))
+		} // reset map
+		testUnmarshalErr(v148v2, bs148, h, t, "dec-map-v148")
+		testDeepEqualErr(v148v1, v148v2, t, "equal-map-v148")
+		if v == nil {
+			v148v2 = nil
+		} else {
+			v148v2 = make(map[uint64]uint, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v148v2), bs148, h, t, "dec-map-v148-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v148v1, v148v2, t, "equal-map-v148-noaddr")
+		if v == nil {
+			v148v2 = nil
+		} else {
+			v148v2 = make(map[uint64]uint, len(v))
+		} // reset map
+		testUnmarshalErr(&v148v2, bs148, h, t, "dec-map-v148-p-len")
+		testDeepEqualErr(v148v1, v148v2, t, "equal-map-v148-p-len")
+		bs148 = testMarshalErr(&v148v1, h, t, "enc-map-v148-p")
+		v148v2 = nil
+		testUnmarshalErr(&v148v2, bs148, h, t, "dec-map-v148-p-nil")
+		testDeepEqualErr(v148v1, v148v2, t, "equal-map-v148-p-nil")
+		// ...
+		if v == nil {
+			v148v2 = nil
+		} else {
+			v148v2 = make(map[uint64]uint, len(v))
+		} // reset map
+		var v148v3, v148v4 typMapMapUint64Uint
+		v148v3 = typMapMapUint64Uint(v148v1)
+		v148v4 = typMapMapUint64Uint(v148v2)
+		bs148 = testMarshalErr(v148v3, h, t, "enc-map-v148-custom")
+		testUnmarshalErr(v148v4, bs148, h, t, "dec-map-v148-p-len")
+		testDeepEqualErr(v148v3, v148v4, t, "equal-map-v148-p-len")
+	}
+
+	for _, v := range []map[uint64]uint8{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v149: %v\n", v)
+		var v149v1, v149v2 map[uint64]uint8
+		v149v1 = v
+		bs149 := testMarshalErr(v149v1, h, t, "enc-map-v149")
+		if v == nil {
+			v149v2 = nil
+		} else {
+			v149v2 = make(map[uint64]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(v149v2, bs149, h, t, "dec-map-v149")
+		testDeepEqualErr(v149v1, v149v2, t, "equal-map-v149")
+		if v == nil {
+			v149v2 = nil
+		} else {
+			v149v2 = make(map[uint64]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v149v2), bs149, h, t, "dec-map-v149-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v149v1, v149v2, t, "equal-map-v149-noaddr")
+		if v == nil {
+			v149v2 = nil
+		} else {
+			v149v2 = make(map[uint64]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(&v149v2, bs149, h, t, "dec-map-v149-p-len")
+		testDeepEqualErr(v149v1, v149v2, t, "equal-map-v149-p-len")
+		bs149 = testMarshalErr(&v149v1, h, t, "enc-map-v149-p")
+		v149v2 = nil
+		testUnmarshalErr(&v149v2, bs149, h, t, "dec-map-v149-p-nil")
+		testDeepEqualErr(v149v1, v149v2, t, "equal-map-v149-p-nil")
+		// ...
+		if v == nil {
+			v149v2 = nil
+		} else {
+			v149v2 = make(map[uint64]uint8, len(v))
+		} // reset map
+		var v149v3, v149v4 typMapMapUint64Uint8
+		v149v3 = typMapMapUint64Uint8(v149v1)
+		v149v4 = typMapMapUint64Uint8(v149v2)
+		bs149 = testMarshalErr(v149v3, h, t, "enc-map-v149-custom")
+		testUnmarshalErr(v149v4, bs149, h, t, "dec-map-v149-p-len")
+		testDeepEqualErr(v149v3, v149v4, t, "equal-map-v149-p-len")
+	}
+
+	for _, v := range []map[uint64]uint16{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v150: %v\n", v)
+		var v150v1, v150v2 map[uint64]uint16
+		v150v1 = v
+		bs150 := testMarshalErr(v150v1, h, t, "enc-map-v150")
+		if v == nil {
+			v150v2 = nil
+		} else {
+			v150v2 = make(map[uint64]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(v150v2, bs150, h, t, "dec-map-v150")
+		testDeepEqualErr(v150v1, v150v2, t, "equal-map-v150")
+		if v == nil {
+			v150v2 = nil
+		} else {
+			v150v2 = make(map[uint64]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v150v2), bs150, h, t, "dec-map-v150-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v150v1, v150v2, t, "equal-map-v150-noaddr")
+		if v == nil {
+			v150v2 = nil
+		} else {
+			v150v2 = make(map[uint64]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(&v150v2, bs150, h, t, "dec-map-v150-p-len")
+		testDeepEqualErr(v150v1, v150v2, t, "equal-map-v150-p-len")
+		bs150 = testMarshalErr(&v150v1, h, t, "enc-map-v150-p")
+		v150v2 = nil
+		testUnmarshalErr(&v150v2, bs150, h, t, "dec-map-v150-p-nil")
+		testDeepEqualErr(v150v1, v150v2, t, "equal-map-v150-p-nil")
+		// ...
+		if v == nil {
+			v150v2 = nil
+		} else {
+			v150v2 = make(map[uint64]uint16, len(v))
+		} // reset map
+		var v150v3, v150v4 typMapMapUint64Uint16
+		v150v3 = typMapMapUint64Uint16(v150v1)
+		v150v4 = typMapMapUint64Uint16(v150v2)
+		bs150 = testMarshalErr(v150v3, h, t, "enc-map-v150-custom")
+		testUnmarshalErr(v150v4, bs150, h, t, "dec-map-v150-p-len")
+		testDeepEqualErr(v150v3, v150v4, t, "equal-map-v150-p-len")
+	}
+
+	for _, v := range []map[uint64]uint32{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v151: %v\n", v)
+		var v151v1, v151v2 map[uint64]uint32
+		v151v1 = v
+		bs151 := testMarshalErr(v151v1, h, t, "enc-map-v151")
+		if v == nil {
+			v151v2 = nil
+		} else {
+			v151v2 = make(map[uint64]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(v151v2, bs151, h, t, "dec-map-v151")
+		testDeepEqualErr(v151v1, v151v2, t, "equal-map-v151")
+		if v == nil {
+			v151v2 = nil
+		} else {
+			v151v2 = make(map[uint64]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v151v2), bs151, h, t, "dec-map-v151-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v151v1, v151v2, t, "equal-map-v151-noaddr")
+		if v == nil {
+			v151v2 = nil
+		} else {
+			v151v2 = make(map[uint64]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(&v151v2, bs151, h, t, "dec-map-v151-p-len")
+		testDeepEqualErr(v151v1, v151v2, t, "equal-map-v151-p-len")
+		bs151 = testMarshalErr(&v151v1, h, t, "enc-map-v151-p")
+		v151v2 = nil
+		testUnmarshalErr(&v151v2, bs151, h, t, "dec-map-v151-p-nil")
+		testDeepEqualErr(v151v1, v151v2, t, "equal-map-v151-p-nil")
+		// ...
+		if v == nil {
+			v151v2 = nil
+		} else {
+			v151v2 = make(map[uint64]uint32, len(v))
+		} // reset map
+		var v151v3, v151v4 typMapMapUint64Uint32
+		v151v3 = typMapMapUint64Uint32(v151v1)
+		v151v4 = typMapMapUint64Uint32(v151v2)
+		bs151 = testMarshalErr(v151v3, h, t, "enc-map-v151-custom")
+		testUnmarshalErr(v151v4, bs151, h, t, "dec-map-v151-p-len")
+		testDeepEqualErr(v151v3, v151v4, t, "equal-map-v151-p-len")
+	}
+
+	for _, v := range []map[uint64]uint64{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v152: %v\n", v)
+		var v152v1, v152v2 map[uint64]uint64
+		v152v1 = v
+		bs152 := testMarshalErr(v152v1, h, t, "enc-map-v152")
+		if v == nil {
+			v152v2 = nil
+		} else {
+			v152v2 = make(map[uint64]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(v152v2, bs152, h, t, "dec-map-v152")
+		testDeepEqualErr(v152v1, v152v2, t, "equal-map-v152")
+		if v == nil {
+			v152v2 = nil
+		} else {
+			v152v2 = make(map[uint64]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v152v2), bs152, h, t, "dec-map-v152-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v152v1, v152v2, t, "equal-map-v152-noaddr")
+		if v == nil {
+			v152v2 = nil
+		} else {
+			v152v2 = make(map[uint64]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(&v152v2, bs152, h, t, "dec-map-v152-p-len")
+		testDeepEqualErr(v152v1, v152v2, t, "equal-map-v152-p-len")
+		bs152 = testMarshalErr(&v152v1, h, t, "enc-map-v152-p")
+		v152v2 = nil
+		testUnmarshalErr(&v152v2, bs152, h, t, "dec-map-v152-p-nil")
+		testDeepEqualErr(v152v1, v152v2, t, "equal-map-v152-p-nil")
+		// ...
+		if v == nil {
+			v152v2 = nil
+		} else {
+			v152v2 = make(map[uint64]uint64, len(v))
+		} // reset map
+		var v152v3, v152v4 typMapMapUint64Uint64
+		v152v3 = typMapMapUint64Uint64(v152v1)
+		v152v4 = typMapMapUint64Uint64(v152v2)
+		bs152 = testMarshalErr(v152v3, h, t, "enc-map-v152-custom")
+		testUnmarshalErr(v152v4, bs152, h, t, "dec-map-v152-p-len")
+		testDeepEqualErr(v152v3, v152v4, t, "equal-map-v152-p-len")
+	}
+
+	for _, v := range []map[uint64]uintptr{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v153: %v\n", v)
+		var v153v1, v153v2 map[uint64]uintptr
+		v153v1 = v
+		bs153 := testMarshalErr(v153v1, h, t, "enc-map-v153")
+		if v == nil {
+			v153v2 = nil
+		} else {
+			v153v2 = make(map[uint64]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(v153v2, bs153, h, t, "dec-map-v153")
+		testDeepEqualErr(v153v1, v153v2, t, "equal-map-v153")
+		if v == nil {
+			v153v2 = nil
+		} else {
+			v153v2 = make(map[uint64]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v153v2), bs153, h, t, "dec-map-v153-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v153v1, v153v2, t, "equal-map-v153-noaddr")
+		if v == nil {
+			v153v2 = nil
+		} else {
+			v153v2 = make(map[uint64]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(&v153v2, bs153, h, t, "dec-map-v153-p-len")
+		testDeepEqualErr(v153v1, v153v2, t, "equal-map-v153-p-len")
+		bs153 = testMarshalErr(&v153v1, h, t, "enc-map-v153-p")
+		v153v2 = nil
+		testUnmarshalErr(&v153v2, bs153, h, t, "dec-map-v153-p-nil")
+		testDeepEqualErr(v153v1, v153v2, t, "equal-map-v153-p-nil")
+		// ...
+		if v == nil {
+			v153v2 = nil
+		} else {
+			v153v2 = make(map[uint64]uintptr, len(v))
+		} // reset map
+		var v153v3, v153v4 typMapMapUint64Uintptr
+		v153v3 = typMapMapUint64Uintptr(v153v1)
+		v153v4 = typMapMapUint64Uintptr(v153v2)
+		bs153 = testMarshalErr(v153v3, h, t, "enc-map-v153-custom")
+		testUnmarshalErr(v153v4, bs153, h, t, "dec-map-v153-p-len")
+		testDeepEqualErr(v153v3, v153v4, t, "equal-map-v153-p-len")
+	}
+
+	for _, v := range []map[uint64]int{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v154: %v\n", v)
+		var v154v1, v154v2 map[uint64]int
+		v154v1 = v
+		bs154 := testMarshalErr(v154v1, h, t, "enc-map-v154")
+		if v == nil {
+			v154v2 = nil
+		} else {
+			v154v2 = make(map[uint64]int, len(v))
+		} // reset map
+		testUnmarshalErr(v154v2, bs154, h, t, "dec-map-v154")
+		testDeepEqualErr(v154v1, v154v2, t, "equal-map-v154")
+		if v == nil {
+			v154v2 = nil
+		} else {
+			v154v2 = make(map[uint64]int, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v154v2), bs154, h, t, "dec-map-v154-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v154v1, v154v2, t, "equal-map-v154-noaddr")
+		if v == nil {
+			v154v2 = nil
+		} else {
+			v154v2 = make(map[uint64]int, len(v))
+		} // reset map
+		testUnmarshalErr(&v154v2, bs154, h, t, "dec-map-v154-p-len")
+		testDeepEqualErr(v154v1, v154v2, t, "equal-map-v154-p-len")
+		bs154 = testMarshalErr(&v154v1, h, t, "enc-map-v154-p")
+		v154v2 = nil
+		testUnmarshalErr(&v154v2, bs154, h, t, "dec-map-v154-p-nil")
+		testDeepEqualErr(v154v1, v154v2, t, "equal-map-v154-p-nil")
+		// ...
+		if v == nil {
+			v154v2 = nil
+		} else {
+			v154v2 = make(map[uint64]int, len(v))
+		} // reset map
+		var v154v3, v154v4 typMapMapUint64Int
+		v154v3 = typMapMapUint64Int(v154v1)
+		v154v4 = typMapMapUint64Int(v154v2)
+		bs154 = testMarshalErr(v154v3, h, t, "enc-map-v154-custom")
+		testUnmarshalErr(v154v4, bs154, h, t, "dec-map-v154-p-len")
+		testDeepEqualErr(v154v3, v154v4, t, "equal-map-v154-p-len")
+	}
+
+	for _, v := range []map[uint64]int8{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v155: %v\n", v)
+		var v155v1, v155v2 map[uint64]int8
+		v155v1 = v
+		bs155 := testMarshalErr(v155v1, h, t, "enc-map-v155")
+		if v == nil {
+			v155v2 = nil
+		} else {
+			v155v2 = make(map[uint64]int8, len(v))
+		} // reset map
+		testUnmarshalErr(v155v2, bs155, h, t, "dec-map-v155")
+		testDeepEqualErr(v155v1, v155v2, t, "equal-map-v155")
+		if v == nil {
+			v155v2 = nil
+		} else {
+			v155v2 = make(map[uint64]int8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v155v2), bs155, h, t, "dec-map-v155-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v155v1, v155v2, t, "equal-map-v155-noaddr")
+		if v == nil {
+			v155v2 = nil
+		} else {
+			v155v2 = make(map[uint64]int8, len(v))
+		} // reset map
+		testUnmarshalErr(&v155v2, bs155, h, t, "dec-map-v155-p-len")
+		testDeepEqualErr(v155v1, v155v2, t, "equal-map-v155-p-len")
+		bs155 = testMarshalErr(&v155v1, h, t, "enc-map-v155-p")
+		v155v2 = nil
+		testUnmarshalErr(&v155v2, bs155, h, t, "dec-map-v155-p-nil")
+		testDeepEqualErr(v155v1, v155v2, t, "equal-map-v155-p-nil")
+		// ...
+		if v == nil {
+			v155v2 = nil
+		} else {
+			v155v2 = make(map[uint64]int8, len(v))
+		} // reset map
+		var v155v3, v155v4 typMapMapUint64Int8
+		v155v3 = typMapMapUint64Int8(v155v1)
+		v155v4 = typMapMapUint64Int8(v155v2)
+		bs155 = testMarshalErr(v155v3, h, t, "enc-map-v155-custom")
+		testUnmarshalErr(v155v4, bs155, h, t, "dec-map-v155-p-len")
+		testDeepEqualErr(v155v3, v155v4, t, "equal-map-v155-p-len")
+	}
+
+	for _, v := range []map[uint64]int16{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v156: %v\n", v)
+		var v156v1, v156v2 map[uint64]int16
+		v156v1 = v
+		bs156 := testMarshalErr(v156v1, h, t, "enc-map-v156")
+		if v == nil {
+			v156v2 = nil
+		} else {
+			v156v2 = make(map[uint64]int16, len(v))
+		} // reset map
+		testUnmarshalErr(v156v2, bs156, h, t, "dec-map-v156")
+		testDeepEqualErr(v156v1, v156v2, t, "equal-map-v156")
+		if v == nil {
+			v156v2 = nil
+		} else {
+			v156v2 = make(map[uint64]int16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v156v2), bs156, h, t, "dec-map-v156-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v156v1, v156v2, t, "equal-map-v156-noaddr")
+		if v == nil {
+			v156v2 = nil
+		} else {
+			v156v2 = make(map[uint64]int16, len(v))
+		} // reset map
+		testUnmarshalErr(&v156v2, bs156, h, t, "dec-map-v156-p-len")
+		testDeepEqualErr(v156v1, v156v2, t, "equal-map-v156-p-len")
+		bs156 = testMarshalErr(&v156v1, h, t, "enc-map-v156-p")
+		v156v2 = nil
+		testUnmarshalErr(&v156v2, bs156, h, t, "dec-map-v156-p-nil")
+		testDeepEqualErr(v156v1, v156v2, t, "equal-map-v156-p-nil")
+		// ...
+		if v == nil {
+			v156v2 = nil
+		} else {
+			v156v2 = make(map[uint64]int16, len(v))
+		} // reset map
+		var v156v3, v156v4 typMapMapUint64Int16
+		v156v3 = typMapMapUint64Int16(v156v1)
+		v156v4 = typMapMapUint64Int16(v156v2)
+		bs156 = testMarshalErr(v156v3, h, t, "enc-map-v156-custom")
+		testUnmarshalErr(v156v4, bs156, h, t, "dec-map-v156-p-len")
+		testDeepEqualErr(v156v3, v156v4, t, "equal-map-v156-p-len")
+	}
+
+	for _, v := range []map[uint64]int32{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v157: %v\n", v)
+		var v157v1, v157v2 map[uint64]int32
+		v157v1 = v
+		bs157 := testMarshalErr(v157v1, h, t, "enc-map-v157")
+		if v == nil {
+			v157v2 = nil
+		} else {
+			v157v2 = make(map[uint64]int32, len(v))
+		} // reset map
+		testUnmarshalErr(v157v2, bs157, h, t, "dec-map-v157")
+		testDeepEqualErr(v157v1, v157v2, t, "equal-map-v157")
+		if v == nil {
+			v157v2 = nil
+		} else {
+			v157v2 = make(map[uint64]int32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v157v2), bs157, h, t, "dec-map-v157-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v157v1, v157v2, t, "equal-map-v157-noaddr")
+		if v == nil {
+			v157v2 = nil
+		} else {
+			v157v2 = make(map[uint64]int32, len(v))
+		} // reset map
+		testUnmarshalErr(&v157v2, bs157, h, t, "dec-map-v157-p-len")
+		testDeepEqualErr(v157v1, v157v2, t, "equal-map-v157-p-len")
+		bs157 = testMarshalErr(&v157v1, h, t, "enc-map-v157-p")
+		v157v2 = nil
+		testUnmarshalErr(&v157v2, bs157, h, t, "dec-map-v157-p-nil")
+		testDeepEqualErr(v157v1, v157v2, t, "equal-map-v157-p-nil")
+		// ...
+		if v == nil {
+			v157v2 = nil
+		} else {
+			v157v2 = make(map[uint64]int32, len(v))
+		} // reset map
+		var v157v3, v157v4 typMapMapUint64Int32
+		v157v3 = typMapMapUint64Int32(v157v1)
+		v157v4 = typMapMapUint64Int32(v157v2)
+		bs157 = testMarshalErr(v157v3, h, t, "enc-map-v157-custom")
+		testUnmarshalErr(v157v4, bs157, h, t, "dec-map-v157-p-len")
+		testDeepEqualErr(v157v3, v157v4, t, "equal-map-v157-p-len")
+	}
+
+	for _, v := range []map[uint64]int64{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v158: %v\n", v)
+		var v158v1, v158v2 map[uint64]int64
+		v158v1 = v
+		bs158 := testMarshalErr(v158v1, h, t, "enc-map-v158")
+		if v == nil {
+			v158v2 = nil
+		} else {
+			v158v2 = make(map[uint64]int64, len(v))
+		} // reset map
+		testUnmarshalErr(v158v2, bs158, h, t, "dec-map-v158")
+		testDeepEqualErr(v158v1, v158v2, t, "equal-map-v158")
+		if v == nil {
+			v158v2 = nil
+		} else {
+			v158v2 = make(map[uint64]int64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v158v2), bs158, h, t, "dec-map-v158-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v158v1, v158v2, t, "equal-map-v158-noaddr")
+		if v == nil {
+			v158v2 = nil
+		} else {
+			v158v2 = make(map[uint64]int64, len(v))
+		} // reset map
+		testUnmarshalErr(&v158v2, bs158, h, t, "dec-map-v158-p-len")
+		testDeepEqualErr(v158v1, v158v2, t, "equal-map-v158-p-len")
+		bs158 = testMarshalErr(&v158v1, h, t, "enc-map-v158-p")
+		v158v2 = nil
+		testUnmarshalErr(&v158v2, bs158, h, t, "dec-map-v158-p-nil")
+		testDeepEqualErr(v158v1, v158v2, t, "equal-map-v158-p-nil")
+		// ...
+		if v == nil {
+			v158v2 = nil
+		} else {
+			v158v2 = make(map[uint64]int64, len(v))
+		} // reset map
+		var v158v3, v158v4 typMapMapUint64Int64
+		v158v3 = typMapMapUint64Int64(v158v1)
+		v158v4 = typMapMapUint64Int64(v158v2)
+		bs158 = testMarshalErr(v158v3, h, t, "enc-map-v158-custom")
+		testUnmarshalErr(v158v4, bs158, h, t, "dec-map-v158-p-len")
+		testDeepEqualErr(v158v3, v158v4, t, "equal-map-v158-p-len")
+	}
+
+	for _, v := range []map[uint64]float32{nil, {}, {33: 0, 44: 22.2}} {
+		// fmt.Printf(">>>> running mammoth map v159: %v\n", v)
+		var v159v1, v159v2 map[uint64]float32
+		v159v1 = v
+		bs159 := testMarshalErr(v159v1, h, t, "enc-map-v159")
+		if v == nil {
+			v159v2 = nil
+		} else {
+			v159v2 = make(map[uint64]float32, len(v))
+		} // reset map
+		testUnmarshalErr(v159v2, bs159, h, t, "dec-map-v159")
+		testDeepEqualErr(v159v1, v159v2, t, "equal-map-v159")
+		if v == nil {
+			v159v2 = nil
+		} else {
+			v159v2 = make(map[uint64]float32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v159v2), bs159, h, t, "dec-map-v159-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v159v1, v159v2, t, "equal-map-v159-noaddr")
+		if v == nil {
+			v159v2 = nil
+		} else {
+			v159v2 = make(map[uint64]float32, len(v))
+		} // reset map
+		testUnmarshalErr(&v159v2, bs159, h, t, "dec-map-v159-p-len")
+		testDeepEqualErr(v159v1, v159v2, t, "equal-map-v159-p-len")
+		bs159 = testMarshalErr(&v159v1, h, t, "enc-map-v159-p")
+		v159v2 = nil
+		testUnmarshalErr(&v159v2, bs159, h, t, "dec-map-v159-p-nil")
+		testDeepEqualErr(v159v1, v159v2, t, "equal-map-v159-p-nil")
+		// ...
+		if v == nil {
+			v159v2 = nil
+		} else {
+			v159v2 = make(map[uint64]float32, len(v))
+		} // reset map
+		var v159v3, v159v4 typMapMapUint64Float32
+		v159v3 = typMapMapUint64Float32(v159v1)
+		v159v4 = typMapMapUint64Float32(v159v2)
+		bs159 = testMarshalErr(v159v3, h, t, "enc-map-v159-custom")
+		testUnmarshalErr(v159v4, bs159, h, t, "dec-map-v159-p-len")
+		testDeepEqualErr(v159v3, v159v4, t, "equal-map-v159-p-len")
+	}
+
+	for _, v := range []map[uint64]float64{nil, {}, {33: 0, 44: 11.1}} {
+		// fmt.Printf(">>>> running mammoth map v160: %v\n", v)
+		var v160v1, v160v2 map[uint64]float64
+		v160v1 = v
+		bs160 := testMarshalErr(v160v1, h, t, "enc-map-v160")
+		if v == nil {
+			v160v2 = nil
+		} else {
+			v160v2 = make(map[uint64]float64, len(v))
+		} // reset map
+		testUnmarshalErr(v160v2, bs160, h, t, "dec-map-v160")
+		testDeepEqualErr(v160v1, v160v2, t, "equal-map-v160")
+		if v == nil {
+			v160v2 = nil
+		} else {
+			v160v2 = make(map[uint64]float64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v160v2), bs160, h, t, "dec-map-v160-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v160v1, v160v2, t, "equal-map-v160-noaddr")
+		if v == nil {
+			v160v2 = nil
+		} else {
+			v160v2 = make(map[uint64]float64, len(v))
+		} // reset map
+		testUnmarshalErr(&v160v2, bs160, h, t, "dec-map-v160-p-len")
+		testDeepEqualErr(v160v1, v160v2, t, "equal-map-v160-p-len")
+		bs160 = testMarshalErr(&v160v1, h, t, "enc-map-v160-p")
+		v160v2 = nil
+		testUnmarshalErr(&v160v2, bs160, h, t, "dec-map-v160-p-nil")
+		testDeepEqualErr(v160v1, v160v2, t, "equal-map-v160-p-nil")
+		// ...
+		if v == nil {
+			v160v2 = nil
+		} else {
+			v160v2 = make(map[uint64]float64, len(v))
+		} // reset map
+		var v160v3, v160v4 typMapMapUint64Float64
+		v160v3 = typMapMapUint64Float64(v160v1)
+		v160v4 = typMapMapUint64Float64(v160v2)
+		bs160 = testMarshalErr(v160v3, h, t, "enc-map-v160-custom")
+		testUnmarshalErr(v160v4, bs160, h, t, "dec-map-v160-p-len")
+		testDeepEqualErr(v160v3, v160v4, t, "equal-map-v160-p-len")
+	}
+
+	for _, v := range []map[uint64]bool{nil, {}, {33: false, 44: true}} {
+		// fmt.Printf(">>>> running mammoth map v161: %v\n", v)
+		var v161v1, v161v2 map[uint64]bool
+		v161v1 = v
+		bs161 := testMarshalErr(v161v1, h, t, "enc-map-v161")
+		if v == nil {
+			v161v2 = nil
+		} else {
+			v161v2 = make(map[uint64]bool, len(v))
+		} // reset map
+		testUnmarshalErr(v161v2, bs161, h, t, "dec-map-v161")
+		testDeepEqualErr(v161v1, v161v2, t, "equal-map-v161")
+		if v == nil {
+			v161v2 = nil
+		} else {
+			v161v2 = make(map[uint64]bool, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v161v2), bs161, h, t, "dec-map-v161-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v161v1, v161v2, t, "equal-map-v161-noaddr")
+		if v == nil {
+			v161v2 = nil
+		} else {
+			v161v2 = make(map[uint64]bool, len(v))
+		} // reset map
+		testUnmarshalErr(&v161v2, bs161, h, t, "dec-map-v161-p-len")
+		testDeepEqualErr(v161v1, v161v2, t, "equal-map-v161-p-len")
+		bs161 = testMarshalErr(&v161v1, h, t, "enc-map-v161-p")
+		v161v2 = nil
+		testUnmarshalErr(&v161v2, bs161, h, t, "dec-map-v161-p-nil")
+		testDeepEqualErr(v161v1, v161v2, t, "equal-map-v161-p-nil")
+		// ...
+		if v == nil {
+			v161v2 = nil
+		} else {
+			v161v2 = make(map[uint64]bool, len(v))
+		} // reset map
+		var v161v3, v161v4 typMapMapUint64Bool
+		v161v3 = typMapMapUint64Bool(v161v1)
+		v161v4 = typMapMapUint64Bool(v161v2)
+		bs161 = testMarshalErr(v161v3, h, t, "enc-map-v161-custom")
+		testUnmarshalErr(v161v4, bs161, h, t, "dec-map-v161-p-len")
+		testDeepEqualErr(v161v3, v161v4, t, "equal-map-v161-p-len")
+	}
+
+	for _, v := range []map[uintptr]interface{}{nil, {}, {33: nil, 44: "string-is-an-interface"}} {
+		// fmt.Printf(">>>> running mammoth map v164: %v\n", v)
+		var v164v1, v164v2 map[uintptr]interface{}
+		v164v1 = v
+		bs164 := testMarshalErr(v164v1, h, t, "enc-map-v164")
+		if v == nil {
+			v164v2 = nil
+		} else {
+			v164v2 = make(map[uintptr]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(v164v2, bs164, h, t, "dec-map-v164")
+		testDeepEqualErr(v164v1, v164v2, t, "equal-map-v164")
+		if v == nil {
+			v164v2 = nil
+		} else {
+			v164v2 = make(map[uintptr]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v164v2), bs164, h, t, "dec-map-v164-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v164v1, v164v2, t, "equal-map-v164-noaddr")
+		if v == nil {
+			v164v2 = nil
+		} else {
+			v164v2 = make(map[uintptr]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(&v164v2, bs164, h, t, "dec-map-v164-p-len")
+		testDeepEqualErr(v164v1, v164v2, t, "equal-map-v164-p-len")
+		bs164 = testMarshalErr(&v164v1, h, t, "enc-map-v164-p")
+		v164v2 = nil
+		testUnmarshalErr(&v164v2, bs164, h, t, "dec-map-v164-p-nil")
+		testDeepEqualErr(v164v1, v164v2, t, "equal-map-v164-p-nil")
+		// ...
+		if v == nil {
+			v164v2 = nil
+		} else {
+			v164v2 = make(map[uintptr]interface{}, len(v))
+		} // reset map
+		var v164v3, v164v4 typMapMapUintptrIntf
+		v164v3 = typMapMapUintptrIntf(v164v1)
+		v164v4 = typMapMapUintptrIntf(v164v2)
+		bs164 = testMarshalErr(v164v3, h, t, "enc-map-v164-custom")
+		testUnmarshalErr(v164v4, bs164, h, t, "dec-map-v164-p-len")
+		testDeepEqualErr(v164v3, v164v4, t, "equal-map-v164-p-len")
+	}
+
+	for _, v := range []map[uintptr]string{nil, {}, {33: "", 44: "some-string"}} {
+		// fmt.Printf(">>>> running mammoth map v165: %v\n", v)
+		var v165v1, v165v2 map[uintptr]string
+		v165v1 = v
+		bs165 := testMarshalErr(v165v1, h, t, "enc-map-v165")
+		if v == nil {
+			v165v2 = nil
+		} else {
+			v165v2 = make(map[uintptr]string, len(v))
+		} // reset map
+		testUnmarshalErr(v165v2, bs165, h, t, "dec-map-v165")
+		testDeepEqualErr(v165v1, v165v2, t, "equal-map-v165")
+		if v == nil {
+			v165v2 = nil
+		} else {
+			v165v2 = make(map[uintptr]string, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v165v2), bs165, h, t, "dec-map-v165-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v165v1, v165v2, t, "equal-map-v165-noaddr")
+		if v == nil {
+			v165v2 = nil
+		} else {
+			v165v2 = make(map[uintptr]string, len(v))
+		} // reset map
+		testUnmarshalErr(&v165v2, bs165, h, t, "dec-map-v165-p-len")
+		testDeepEqualErr(v165v1, v165v2, t, "equal-map-v165-p-len")
+		bs165 = testMarshalErr(&v165v1, h, t, "enc-map-v165-p")
+		v165v2 = nil
+		testUnmarshalErr(&v165v2, bs165, h, t, "dec-map-v165-p-nil")
+		testDeepEqualErr(v165v1, v165v2, t, "equal-map-v165-p-nil")
+		// ...
+		if v == nil {
+			v165v2 = nil
+		} else {
+			v165v2 = make(map[uintptr]string, len(v))
+		} // reset map
+		var v165v3, v165v4 typMapMapUintptrString
+		v165v3 = typMapMapUintptrString(v165v1)
+		v165v4 = typMapMapUintptrString(v165v2)
+		bs165 = testMarshalErr(v165v3, h, t, "enc-map-v165-custom")
+		testUnmarshalErr(v165v4, bs165, h, t, "dec-map-v165-p-len")
+		testDeepEqualErr(v165v3, v165v4, t, "equal-map-v165-p-len")
+	}
+
+	for _, v := range []map[uintptr]uint{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v166: %v\n", v)
+		var v166v1, v166v2 map[uintptr]uint
+		v166v1 = v
+		bs166 := testMarshalErr(v166v1, h, t, "enc-map-v166")
+		if v == nil {
+			v166v2 = nil
+		} else {
+			v166v2 = make(map[uintptr]uint, len(v))
+		} // reset map
+		testUnmarshalErr(v166v2, bs166, h, t, "dec-map-v166")
+		testDeepEqualErr(v166v1, v166v2, t, "equal-map-v166")
+		if v == nil {
+			v166v2 = nil
+		} else {
+			v166v2 = make(map[uintptr]uint, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v166v2), bs166, h, t, "dec-map-v166-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v166v1, v166v2, t, "equal-map-v166-noaddr")
+		if v == nil {
+			v166v2 = nil
+		} else {
+			v166v2 = make(map[uintptr]uint, len(v))
+		} // reset map
+		testUnmarshalErr(&v166v2, bs166, h, t, "dec-map-v166-p-len")
+		testDeepEqualErr(v166v1, v166v2, t, "equal-map-v166-p-len")
+		bs166 = testMarshalErr(&v166v1, h, t, "enc-map-v166-p")
+		v166v2 = nil
+		testUnmarshalErr(&v166v2, bs166, h, t, "dec-map-v166-p-nil")
+		testDeepEqualErr(v166v1, v166v2, t, "equal-map-v166-p-nil")
+		// ...
+		if v == nil {
+			v166v2 = nil
+		} else {
+			v166v2 = make(map[uintptr]uint, len(v))
+		} // reset map
+		var v166v3, v166v4 typMapMapUintptrUint
+		v166v3 = typMapMapUintptrUint(v166v1)
+		v166v4 = typMapMapUintptrUint(v166v2)
+		bs166 = testMarshalErr(v166v3, h, t, "enc-map-v166-custom")
+		testUnmarshalErr(v166v4, bs166, h, t, "dec-map-v166-p-len")
+		testDeepEqualErr(v166v3, v166v4, t, "equal-map-v166-p-len")
+	}
+
+	for _, v := range []map[uintptr]uint8{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v167: %v\n", v)
+		var v167v1, v167v2 map[uintptr]uint8
+		v167v1 = v
+		bs167 := testMarshalErr(v167v1, h, t, "enc-map-v167")
+		if v == nil {
+			v167v2 = nil
+		} else {
+			v167v2 = make(map[uintptr]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(v167v2, bs167, h, t, "dec-map-v167")
+		testDeepEqualErr(v167v1, v167v2, t, "equal-map-v167")
+		if v == nil {
+			v167v2 = nil
+		} else {
+			v167v2 = make(map[uintptr]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v167v2), bs167, h, t, "dec-map-v167-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v167v1, v167v2, t, "equal-map-v167-noaddr")
+		if v == nil {
+			v167v2 = nil
+		} else {
+			v167v2 = make(map[uintptr]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(&v167v2, bs167, h, t, "dec-map-v167-p-len")
+		testDeepEqualErr(v167v1, v167v2, t, "equal-map-v167-p-len")
+		bs167 = testMarshalErr(&v167v1, h, t, "enc-map-v167-p")
+		v167v2 = nil
+		testUnmarshalErr(&v167v2, bs167, h, t, "dec-map-v167-p-nil")
+		testDeepEqualErr(v167v1, v167v2, t, "equal-map-v167-p-nil")
+		// ...
+		if v == nil {
+			v167v2 = nil
+		} else {
+			v167v2 = make(map[uintptr]uint8, len(v))
+		} // reset map
+		var v167v3, v167v4 typMapMapUintptrUint8
+		v167v3 = typMapMapUintptrUint8(v167v1)
+		v167v4 = typMapMapUintptrUint8(v167v2)
+		bs167 = testMarshalErr(v167v3, h, t, "enc-map-v167-custom")
+		testUnmarshalErr(v167v4, bs167, h, t, "dec-map-v167-p-len")
+		testDeepEqualErr(v167v3, v167v4, t, "equal-map-v167-p-len")
+	}
+
+	for _, v := range []map[uintptr]uint16{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v168: %v\n", v)
+		var v168v1, v168v2 map[uintptr]uint16
+		v168v1 = v
+		bs168 := testMarshalErr(v168v1, h, t, "enc-map-v168")
+		if v == nil {
+			v168v2 = nil
+		} else {
+			v168v2 = make(map[uintptr]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(v168v2, bs168, h, t, "dec-map-v168")
+		testDeepEqualErr(v168v1, v168v2, t, "equal-map-v168")
+		if v == nil {
+			v168v2 = nil
+		} else {
+			v168v2 = make(map[uintptr]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v168v2), bs168, h, t, "dec-map-v168-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v168v1, v168v2, t, "equal-map-v168-noaddr")
+		if v == nil {
+			v168v2 = nil
+		} else {
+			v168v2 = make(map[uintptr]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(&v168v2, bs168, h, t, "dec-map-v168-p-len")
+		testDeepEqualErr(v168v1, v168v2, t, "equal-map-v168-p-len")
+		bs168 = testMarshalErr(&v168v1, h, t, "enc-map-v168-p")
+		v168v2 = nil
+		testUnmarshalErr(&v168v2, bs168, h, t, "dec-map-v168-p-nil")
+		testDeepEqualErr(v168v1, v168v2, t, "equal-map-v168-p-nil")
+		// ...
+		if v == nil {
+			v168v2 = nil
+		} else {
+			v168v2 = make(map[uintptr]uint16, len(v))
+		} // reset map
+		var v168v3, v168v4 typMapMapUintptrUint16
+		v168v3 = typMapMapUintptrUint16(v168v1)
+		v168v4 = typMapMapUintptrUint16(v168v2)
+		bs168 = testMarshalErr(v168v3, h, t, "enc-map-v168-custom")
+		testUnmarshalErr(v168v4, bs168, h, t, "dec-map-v168-p-len")
+		testDeepEqualErr(v168v3, v168v4, t, "equal-map-v168-p-len")
+	}
+
+	for _, v := range []map[uintptr]uint32{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v169: %v\n", v)
+		var v169v1, v169v2 map[uintptr]uint32
+		v169v1 = v
+		bs169 := testMarshalErr(v169v1, h, t, "enc-map-v169")
+		if v == nil {
+			v169v2 = nil
+		} else {
+			v169v2 = make(map[uintptr]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(v169v2, bs169, h, t, "dec-map-v169")
+		testDeepEqualErr(v169v1, v169v2, t, "equal-map-v169")
+		if v == nil {
+			v169v2 = nil
+		} else {
+			v169v2 = make(map[uintptr]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v169v2), bs169, h, t, "dec-map-v169-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v169v1, v169v2, t, "equal-map-v169-noaddr")
+		if v == nil {
+			v169v2 = nil
+		} else {
+			v169v2 = make(map[uintptr]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(&v169v2, bs169, h, t, "dec-map-v169-p-len")
+		testDeepEqualErr(v169v1, v169v2, t, "equal-map-v169-p-len")
+		bs169 = testMarshalErr(&v169v1, h, t, "enc-map-v169-p")
+		v169v2 = nil
+		testUnmarshalErr(&v169v2, bs169, h, t, "dec-map-v169-p-nil")
+		testDeepEqualErr(v169v1, v169v2, t, "equal-map-v169-p-nil")
+		// ...
+		if v == nil {
+			v169v2 = nil
+		} else {
+			v169v2 = make(map[uintptr]uint32, len(v))
+		} // reset map
+		var v169v3, v169v4 typMapMapUintptrUint32
+		v169v3 = typMapMapUintptrUint32(v169v1)
+		v169v4 = typMapMapUintptrUint32(v169v2)
+		bs169 = testMarshalErr(v169v3, h, t, "enc-map-v169-custom")
+		testUnmarshalErr(v169v4, bs169, h, t, "dec-map-v169-p-len")
+		testDeepEqualErr(v169v3, v169v4, t, "equal-map-v169-p-len")
+	}
+
+	for _, v := range []map[uintptr]uint64{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v170: %v\n", v)
+		var v170v1, v170v2 map[uintptr]uint64
+		v170v1 = v
+		bs170 := testMarshalErr(v170v1, h, t, "enc-map-v170")
+		if v == nil {
+			v170v2 = nil
+		} else {
+			v170v2 = make(map[uintptr]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(v170v2, bs170, h, t, "dec-map-v170")
+		testDeepEqualErr(v170v1, v170v2, t, "equal-map-v170")
+		if v == nil {
+			v170v2 = nil
+		} else {
+			v170v2 = make(map[uintptr]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v170v2), bs170, h, t, "dec-map-v170-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v170v1, v170v2, t, "equal-map-v170-noaddr")
+		if v == nil {
+			v170v2 = nil
+		} else {
+			v170v2 = make(map[uintptr]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(&v170v2, bs170, h, t, "dec-map-v170-p-len")
+		testDeepEqualErr(v170v1, v170v2, t, "equal-map-v170-p-len")
+		bs170 = testMarshalErr(&v170v1, h, t, "enc-map-v170-p")
+		v170v2 = nil
+		testUnmarshalErr(&v170v2, bs170, h, t, "dec-map-v170-p-nil")
+		testDeepEqualErr(v170v1, v170v2, t, "equal-map-v170-p-nil")
+		// ...
+		if v == nil {
+			v170v2 = nil
+		} else {
+			v170v2 = make(map[uintptr]uint64, len(v))
+		} // reset map
+		var v170v3, v170v4 typMapMapUintptrUint64
+		v170v3 = typMapMapUintptrUint64(v170v1)
+		v170v4 = typMapMapUintptrUint64(v170v2)
+		bs170 = testMarshalErr(v170v3, h, t, "enc-map-v170-custom")
+		testUnmarshalErr(v170v4, bs170, h, t, "dec-map-v170-p-len")
+		testDeepEqualErr(v170v3, v170v4, t, "equal-map-v170-p-len")
+	}
+
+	for _, v := range []map[uintptr]uintptr{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v171: %v\n", v)
+		var v171v1, v171v2 map[uintptr]uintptr
+		v171v1 = v
+		bs171 := testMarshalErr(v171v1, h, t, "enc-map-v171")
+		if v == nil {
+			v171v2 = nil
+		} else {
+			v171v2 = make(map[uintptr]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(v171v2, bs171, h, t, "dec-map-v171")
+		testDeepEqualErr(v171v1, v171v2, t, "equal-map-v171")
+		if v == nil {
+			v171v2 = nil
+		} else {
+			v171v2 = make(map[uintptr]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v171v2), bs171, h, t, "dec-map-v171-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v171v1, v171v2, t, "equal-map-v171-noaddr")
+		if v == nil {
+			v171v2 = nil
+		} else {
+			v171v2 = make(map[uintptr]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(&v171v2, bs171, h, t, "dec-map-v171-p-len")
+		testDeepEqualErr(v171v1, v171v2, t, "equal-map-v171-p-len")
+		bs171 = testMarshalErr(&v171v1, h, t, "enc-map-v171-p")
+		v171v2 = nil
+		testUnmarshalErr(&v171v2, bs171, h, t, "dec-map-v171-p-nil")
+		testDeepEqualErr(v171v1, v171v2, t, "equal-map-v171-p-nil")
+		// ...
+		if v == nil {
+			v171v2 = nil
+		} else {
+			v171v2 = make(map[uintptr]uintptr, len(v))
+		} // reset map
+		var v171v3, v171v4 typMapMapUintptrUintptr
+		v171v3 = typMapMapUintptrUintptr(v171v1)
+		v171v4 = typMapMapUintptrUintptr(v171v2)
+		bs171 = testMarshalErr(v171v3, h, t, "enc-map-v171-custom")
+		testUnmarshalErr(v171v4, bs171, h, t, "dec-map-v171-p-len")
+		testDeepEqualErr(v171v3, v171v4, t, "equal-map-v171-p-len")
+	}
+
+	for _, v := range []map[uintptr]int{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v172: %v\n", v)
+		var v172v1, v172v2 map[uintptr]int
+		v172v1 = v
+		bs172 := testMarshalErr(v172v1, h, t, "enc-map-v172")
+		if v == nil {
+			v172v2 = nil
+		} else {
+			v172v2 = make(map[uintptr]int, len(v))
+		} // reset map
+		testUnmarshalErr(v172v2, bs172, h, t, "dec-map-v172")
+		testDeepEqualErr(v172v1, v172v2, t, "equal-map-v172")
+		if v == nil {
+			v172v2 = nil
+		} else {
+			v172v2 = make(map[uintptr]int, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v172v2), bs172, h, t, "dec-map-v172-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v172v1, v172v2, t, "equal-map-v172-noaddr")
+		if v == nil {
+			v172v2 = nil
+		} else {
+			v172v2 = make(map[uintptr]int, len(v))
+		} // reset map
+		testUnmarshalErr(&v172v2, bs172, h, t, "dec-map-v172-p-len")
+		testDeepEqualErr(v172v1, v172v2, t, "equal-map-v172-p-len")
+		bs172 = testMarshalErr(&v172v1, h, t, "enc-map-v172-p")
+		v172v2 = nil
+		testUnmarshalErr(&v172v2, bs172, h, t, "dec-map-v172-p-nil")
+		testDeepEqualErr(v172v1, v172v2, t, "equal-map-v172-p-nil")
+		// ...
+		if v == nil {
+			v172v2 = nil
+		} else {
+			v172v2 = make(map[uintptr]int, len(v))
+		} // reset map
+		var v172v3, v172v4 typMapMapUintptrInt
+		v172v3 = typMapMapUintptrInt(v172v1)
+		v172v4 = typMapMapUintptrInt(v172v2)
+		bs172 = testMarshalErr(v172v3, h, t, "enc-map-v172-custom")
+		testUnmarshalErr(v172v4, bs172, h, t, "dec-map-v172-p-len")
+		testDeepEqualErr(v172v3, v172v4, t, "equal-map-v172-p-len")
+	}
+
+	for _, v := range []map[uintptr]int8{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v173: %v\n", v)
+		var v173v1, v173v2 map[uintptr]int8
+		v173v1 = v
+		bs173 := testMarshalErr(v173v1, h, t, "enc-map-v173")
+		if v == nil {
+			v173v2 = nil
+		} else {
+			v173v2 = make(map[uintptr]int8, len(v))
+		} // reset map
+		testUnmarshalErr(v173v2, bs173, h, t, "dec-map-v173")
+		testDeepEqualErr(v173v1, v173v2, t, "equal-map-v173")
+		if v == nil {
+			v173v2 = nil
+		} else {
+			v173v2 = make(map[uintptr]int8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v173v2), bs173, h, t, "dec-map-v173-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v173v1, v173v2, t, "equal-map-v173-noaddr")
+		if v == nil {
+			v173v2 = nil
+		} else {
+			v173v2 = make(map[uintptr]int8, len(v))
+		} // reset map
+		testUnmarshalErr(&v173v2, bs173, h, t, "dec-map-v173-p-len")
+		testDeepEqualErr(v173v1, v173v2, t, "equal-map-v173-p-len")
+		bs173 = testMarshalErr(&v173v1, h, t, "enc-map-v173-p")
+		v173v2 = nil
+		testUnmarshalErr(&v173v2, bs173, h, t, "dec-map-v173-p-nil")
+		testDeepEqualErr(v173v1, v173v2, t, "equal-map-v173-p-nil")
+		// ...
+		if v == nil {
+			v173v2 = nil
+		} else {
+			v173v2 = make(map[uintptr]int8, len(v))
+		} // reset map
+		var v173v3, v173v4 typMapMapUintptrInt8
+		v173v3 = typMapMapUintptrInt8(v173v1)
+		v173v4 = typMapMapUintptrInt8(v173v2)
+		bs173 = testMarshalErr(v173v3, h, t, "enc-map-v173-custom")
+		testUnmarshalErr(v173v4, bs173, h, t, "dec-map-v173-p-len")
+		testDeepEqualErr(v173v3, v173v4, t, "equal-map-v173-p-len")
+	}
+
+	for _, v := range []map[uintptr]int16{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v174: %v\n", v)
+		var v174v1, v174v2 map[uintptr]int16
+		v174v1 = v
+		bs174 := testMarshalErr(v174v1, h, t, "enc-map-v174")
+		if v == nil {
+			v174v2 = nil
+		} else {
+			v174v2 = make(map[uintptr]int16, len(v))
+		} // reset map
+		testUnmarshalErr(v174v2, bs174, h, t, "dec-map-v174")
+		testDeepEqualErr(v174v1, v174v2, t, "equal-map-v174")
+		if v == nil {
+			v174v2 = nil
+		} else {
+			v174v2 = make(map[uintptr]int16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v174v2), bs174, h, t, "dec-map-v174-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v174v1, v174v2, t, "equal-map-v174-noaddr")
+		if v == nil {
+			v174v2 = nil
+		} else {
+			v174v2 = make(map[uintptr]int16, len(v))
+		} // reset map
+		testUnmarshalErr(&v174v2, bs174, h, t, "dec-map-v174-p-len")
+		testDeepEqualErr(v174v1, v174v2, t, "equal-map-v174-p-len")
+		bs174 = testMarshalErr(&v174v1, h, t, "enc-map-v174-p")
+		v174v2 = nil
+		testUnmarshalErr(&v174v2, bs174, h, t, "dec-map-v174-p-nil")
+		testDeepEqualErr(v174v1, v174v2, t, "equal-map-v174-p-nil")
+		// ...
+		if v == nil {
+			v174v2 = nil
+		} else {
+			v174v2 = make(map[uintptr]int16, len(v))
+		} // reset map
+		var v174v3, v174v4 typMapMapUintptrInt16
+		v174v3 = typMapMapUintptrInt16(v174v1)
+		v174v4 = typMapMapUintptrInt16(v174v2)
+		bs174 = testMarshalErr(v174v3, h, t, "enc-map-v174-custom")
+		testUnmarshalErr(v174v4, bs174, h, t, "dec-map-v174-p-len")
+		testDeepEqualErr(v174v3, v174v4, t, "equal-map-v174-p-len")
+	}
+
+	for _, v := range []map[uintptr]int32{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v175: %v\n", v)
+		var v175v1, v175v2 map[uintptr]int32
+		v175v1 = v
+		bs175 := testMarshalErr(v175v1, h, t, "enc-map-v175")
+		if v == nil {
+			v175v2 = nil
+		} else {
+			v175v2 = make(map[uintptr]int32, len(v))
+		} // reset map
+		testUnmarshalErr(v175v2, bs175, h, t, "dec-map-v175")
+		testDeepEqualErr(v175v1, v175v2, t, "equal-map-v175")
+		if v == nil {
+			v175v2 = nil
+		} else {
+			v175v2 = make(map[uintptr]int32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v175v2), bs175, h, t, "dec-map-v175-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v175v1, v175v2, t, "equal-map-v175-noaddr")
+		if v == nil {
+			v175v2 = nil
+		} else {
+			v175v2 = make(map[uintptr]int32, len(v))
+		} // reset map
+		testUnmarshalErr(&v175v2, bs175, h, t, "dec-map-v175-p-len")
+		testDeepEqualErr(v175v1, v175v2, t, "equal-map-v175-p-len")
+		bs175 = testMarshalErr(&v175v1, h, t, "enc-map-v175-p")
+		v175v2 = nil
+		testUnmarshalErr(&v175v2, bs175, h, t, "dec-map-v175-p-nil")
+		testDeepEqualErr(v175v1, v175v2, t, "equal-map-v175-p-nil")
+		// ...
+		if v == nil {
+			v175v2 = nil
+		} else {
+			v175v2 = make(map[uintptr]int32, len(v))
+		} // reset map
+		var v175v3, v175v4 typMapMapUintptrInt32
+		v175v3 = typMapMapUintptrInt32(v175v1)
+		v175v4 = typMapMapUintptrInt32(v175v2)
+		bs175 = testMarshalErr(v175v3, h, t, "enc-map-v175-custom")
+		testUnmarshalErr(v175v4, bs175, h, t, "dec-map-v175-p-len")
+		testDeepEqualErr(v175v3, v175v4, t, "equal-map-v175-p-len")
+	}
+
+	for _, v := range []map[uintptr]int64{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v176: %v\n", v)
+		var v176v1, v176v2 map[uintptr]int64
+		v176v1 = v
+		bs176 := testMarshalErr(v176v1, h, t, "enc-map-v176")
+		if v == nil {
+			v176v2 = nil
+		} else {
+			v176v2 = make(map[uintptr]int64, len(v))
+		} // reset map
+		testUnmarshalErr(v176v2, bs176, h, t, "dec-map-v176")
+		testDeepEqualErr(v176v1, v176v2, t, "equal-map-v176")
+		if v == nil {
+			v176v2 = nil
+		} else {
+			v176v2 = make(map[uintptr]int64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v176v2), bs176, h, t, "dec-map-v176-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v176v1, v176v2, t, "equal-map-v176-noaddr")
+		if v == nil {
+			v176v2 = nil
+		} else {
+			v176v2 = make(map[uintptr]int64, len(v))
+		} // reset map
+		testUnmarshalErr(&v176v2, bs176, h, t, "dec-map-v176-p-len")
+		testDeepEqualErr(v176v1, v176v2, t, "equal-map-v176-p-len")
+		bs176 = testMarshalErr(&v176v1, h, t, "enc-map-v176-p")
+		v176v2 = nil
+		testUnmarshalErr(&v176v2, bs176, h, t, "dec-map-v176-p-nil")
+		testDeepEqualErr(v176v1, v176v2, t, "equal-map-v176-p-nil")
+		// ...
+		if v == nil {
+			v176v2 = nil
+		} else {
+			v176v2 = make(map[uintptr]int64, len(v))
+		} // reset map
+		var v176v3, v176v4 typMapMapUintptrInt64
+		v176v3 = typMapMapUintptrInt64(v176v1)
+		v176v4 = typMapMapUintptrInt64(v176v2)
+		bs176 = testMarshalErr(v176v3, h, t, "enc-map-v176-custom")
+		testUnmarshalErr(v176v4, bs176, h, t, "dec-map-v176-p-len")
+		testDeepEqualErr(v176v3, v176v4, t, "equal-map-v176-p-len")
+	}
+
+	for _, v := range []map[uintptr]float32{nil, {}, {44: 0, 33: 22.2}} {
+		// fmt.Printf(">>>> running mammoth map v177: %v\n", v)
+		var v177v1, v177v2 map[uintptr]float32
+		v177v1 = v
+		bs177 := testMarshalErr(v177v1, h, t, "enc-map-v177")
+		if v == nil {
+			v177v2 = nil
+		} else {
+			v177v2 = make(map[uintptr]float32, len(v))
+		} // reset map
+		testUnmarshalErr(v177v2, bs177, h, t, "dec-map-v177")
+		testDeepEqualErr(v177v1, v177v2, t, "equal-map-v177")
+		if v == nil {
+			v177v2 = nil
+		} else {
+			v177v2 = make(map[uintptr]float32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v177v2), bs177, h, t, "dec-map-v177-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v177v1, v177v2, t, "equal-map-v177-noaddr")
+		if v == nil {
+			v177v2 = nil
+		} else {
+			v177v2 = make(map[uintptr]float32, len(v))
+		} // reset map
+		testUnmarshalErr(&v177v2, bs177, h, t, "dec-map-v177-p-len")
+		testDeepEqualErr(v177v1, v177v2, t, "equal-map-v177-p-len")
+		bs177 = testMarshalErr(&v177v1, h, t, "enc-map-v177-p")
+		v177v2 = nil
+		testUnmarshalErr(&v177v2, bs177, h, t, "dec-map-v177-p-nil")
+		testDeepEqualErr(v177v1, v177v2, t, "equal-map-v177-p-nil")
+		// ...
+		if v == nil {
+			v177v2 = nil
+		} else {
+			v177v2 = make(map[uintptr]float32, len(v))
+		} // reset map
+		var v177v3, v177v4 typMapMapUintptrFloat32
+		v177v3 = typMapMapUintptrFloat32(v177v1)
+		v177v4 = typMapMapUintptrFloat32(v177v2)
+		bs177 = testMarshalErr(v177v3, h, t, "enc-map-v177-custom")
+		testUnmarshalErr(v177v4, bs177, h, t, "dec-map-v177-p-len")
+		testDeepEqualErr(v177v3, v177v4, t, "equal-map-v177-p-len")
+	}
+
+	for _, v := range []map[uintptr]float64{nil, {}, {44: 0, 33: 11.1}} {
+		// fmt.Printf(">>>> running mammoth map v178: %v\n", v)
+		var v178v1, v178v2 map[uintptr]float64
+		v178v1 = v
+		bs178 := testMarshalErr(v178v1, h, t, "enc-map-v178")
+		if v == nil {
+			v178v2 = nil
+		} else {
+			v178v2 = make(map[uintptr]float64, len(v))
+		} // reset map
+		testUnmarshalErr(v178v2, bs178, h, t, "dec-map-v178")
+		testDeepEqualErr(v178v1, v178v2, t, "equal-map-v178")
+		if v == nil {
+			v178v2 = nil
+		} else {
+			v178v2 = make(map[uintptr]float64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v178v2), bs178, h, t, "dec-map-v178-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v178v1, v178v2, t, "equal-map-v178-noaddr")
+		if v == nil {
+			v178v2 = nil
+		} else {
+			v178v2 = make(map[uintptr]float64, len(v))
+		} // reset map
+		testUnmarshalErr(&v178v2, bs178, h, t, "dec-map-v178-p-len")
+		testDeepEqualErr(v178v1, v178v2, t, "equal-map-v178-p-len")
+		bs178 = testMarshalErr(&v178v1, h, t, "enc-map-v178-p")
+		v178v2 = nil
+		testUnmarshalErr(&v178v2, bs178, h, t, "dec-map-v178-p-nil")
+		testDeepEqualErr(v178v1, v178v2, t, "equal-map-v178-p-nil")
+		// ...
+		if v == nil {
+			v178v2 = nil
+		} else {
+			v178v2 = make(map[uintptr]float64, len(v))
+		} // reset map
+		var v178v3, v178v4 typMapMapUintptrFloat64
+		v178v3 = typMapMapUintptrFloat64(v178v1)
+		v178v4 = typMapMapUintptrFloat64(v178v2)
+		bs178 = testMarshalErr(v178v3, h, t, "enc-map-v178-custom")
+		testUnmarshalErr(v178v4, bs178, h, t, "dec-map-v178-p-len")
+		testDeepEqualErr(v178v3, v178v4, t, "equal-map-v178-p-len")
+	}
+
+	for _, v := range []map[uintptr]bool{nil, {}, {44: false, 33: true}} {
+		// fmt.Printf(">>>> running mammoth map v179: %v\n", v)
+		var v179v1, v179v2 map[uintptr]bool
+		v179v1 = v
+		bs179 := testMarshalErr(v179v1, h, t, "enc-map-v179")
+		if v == nil {
+			v179v2 = nil
+		} else {
+			v179v2 = make(map[uintptr]bool, len(v))
+		} // reset map
+		testUnmarshalErr(v179v2, bs179, h, t, "dec-map-v179")
+		testDeepEqualErr(v179v1, v179v2, t, "equal-map-v179")
+		if v == nil {
+			v179v2 = nil
+		} else {
+			v179v2 = make(map[uintptr]bool, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v179v2), bs179, h, t, "dec-map-v179-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v179v1, v179v2, t, "equal-map-v179-noaddr")
+		if v == nil {
+			v179v2 = nil
+		} else {
+			v179v2 = make(map[uintptr]bool, len(v))
+		} // reset map
+		testUnmarshalErr(&v179v2, bs179, h, t, "dec-map-v179-p-len")
+		testDeepEqualErr(v179v1, v179v2, t, "equal-map-v179-p-len")
+		bs179 = testMarshalErr(&v179v1, h, t, "enc-map-v179-p")
+		v179v2 = nil
+		testUnmarshalErr(&v179v2, bs179, h, t, "dec-map-v179-p-nil")
+		testDeepEqualErr(v179v1, v179v2, t, "equal-map-v179-p-nil")
+		// ...
+		if v == nil {
+			v179v2 = nil
+		} else {
+			v179v2 = make(map[uintptr]bool, len(v))
+		} // reset map
+		var v179v3, v179v4 typMapMapUintptrBool
+		v179v3 = typMapMapUintptrBool(v179v1)
+		v179v4 = typMapMapUintptrBool(v179v2)
+		bs179 = testMarshalErr(v179v3, h, t, "enc-map-v179-custom")
+		testUnmarshalErr(v179v4, bs179, h, t, "dec-map-v179-p-len")
+		testDeepEqualErr(v179v3, v179v4, t, "equal-map-v179-p-len")
+	}
+
+	for _, v := range []map[int]interface{}{nil, {}, {44: nil, 33: "string-is-an-interface-2"}} {
+		// fmt.Printf(">>>> running mammoth map v182: %v\n", v)
+		var v182v1, v182v2 map[int]interface{}
+		v182v1 = v
+		bs182 := testMarshalErr(v182v1, h, t, "enc-map-v182")
+		if v == nil {
+			v182v2 = nil
+		} else {
+			v182v2 = make(map[int]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(v182v2, bs182, h, t, "dec-map-v182")
+		testDeepEqualErr(v182v1, v182v2, t, "equal-map-v182")
+		if v == nil {
+			v182v2 = nil
+		} else {
+			v182v2 = make(map[int]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v182v2), bs182, h, t, "dec-map-v182-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v182v1, v182v2, t, "equal-map-v182-noaddr")
+		if v == nil {
+			v182v2 = nil
+		} else {
+			v182v2 = make(map[int]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(&v182v2, bs182, h, t, "dec-map-v182-p-len")
+		testDeepEqualErr(v182v1, v182v2, t, "equal-map-v182-p-len")
+		bs182 = testMarshalErr(&v182v1, h, t, "enc-map-v182-p")
+		v182v2 = nil
+		testUnmarshalErr(&v182v2, bs182, h, t, "dec-map-v182-p-nil")
+		testDeepEqualErr(v182v1, v182v2, t, "equal-map-v182-p-nil")
+		// ...
+		if v == nil {
+			v182v2 = nil
+		} else {
+			v182v2 = make(map[int]interface{}, len(v))
+		} // reset map
+		var v182v3, v182v4 typMapMapIntIntf
+		v182v3 = typMapMapIntIntf(v182v1)
+		v182v4 = typMapMapIntIntf(v182v2)
+		bs182 = testMarshalErr(v182v3, h, t, "enc-map-v182-custom")
+		testUnmarshalErr(v182v4, bs182, h, t, "dec-map-v182-p-len")
+		testDeepEqualErr(v182v3, v182v4, t, "equal-map-v182-p-len")
+	}
+
+	for _, v := range []map[int]string{nil, {}, {44: "", 33: "some-string-2"}} {
+		// fmt.Printf(">>>> running mammoth map v183: %v\n", v)
+		var v183v1, v183v2 map[int]string
+		v183v1 = v
+		bs183 := testMarshalErr(v183v1, h, t, "enc-map-v183")
+		if v == nil {
+			v183v2 = nil
+		} else {
+			v183v2 = make(map[int]string, len(v))
+		} // reset map
+		testUnmarshalErr(v183v2, bs183, h, t, "dec-map-v183")
+		testDeepEqualErr(v183v1, v183v2, t, "equal-map-v183")
+		if v == nil {
+			v183v2 = nil
+		} else {
+			v183v2 = make(map[int]string, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v183v2), bs183, h, t, "dec-map-v183-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v183v1, v183v2, t, "equal-map-v183-noaddr")
+		if v == nil {
+			v183v2 = nil
+		} else {
+			v183v2 = make(map[int]string, len(v))
+		} // reset map
+		testUnmarshalErr(&v183v2, bs183, h, t, "dec-map-v183-p-len")
+		testDeepEqualErr(v183v1, v183v2, t, "equal-map-v183-p-len")
+		bs183 = testMarshalErr(&v183v1, h, t, "enc-map-v183-p")
+		v183v2 = nil
+		testUnmarshalErr(&v183v2, bs183, h, t, "dec-map-v183-p-nil")
+		testDeepEqualErr(v183v1, v183v2, t, "equal-map-v183-p-nil")
+		// ...
+		if v == nil {
+			v183v2 = nil
+		} else {
+			v183v2 = make(map[int]string, len(v))
+		} // reset map
+		var v183v3, v183v4 typMapMapIntString
+		v183v3 = typMapMapIntString(v183v1)
+		v183v4 = typMapMapIntString(v183v2)
+		bs183 = testMarshalErr(v183v3, h, t, "enc-map-v183-custom")
+		testUnmarshalErr(v183v4, bs183, h, t, "dec-map-v183-p-len")
+		testDeepEqualErr(v183v3, v183v4, t, "equal-map-v183-p-len")
+	}
+
+	for _, v := range []map[int]uint{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v184: %v\n", v)
+		var v184v1, v184v2 map[int]uint
+		v184v1 = v
+		bs184 := testMarshalErr(v184v1, h, t, "enc-map-v184")
+		if v == nil {
+			v184v2 = nil
+		} else {
+			v184v2 = make(map[int]uint, len(v))
+		} // reset map
+		testUnmarshalErr(v184v2, bs184, h, t, "dec-map-v184")
+		testDeepEqualErr(v184v1, v184v2, t, "equal-map-v184")
+		if v == nil {
+			v184v2 = nil
+		} else {
+			v184v2 = make(map[int]uint, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v184v2), bs184, h, t, "dec-map-v184-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v184v1, v184v2, t, "equal-map-v184-noaddr")
+		if v == nil {
+			v184v2 = nil
+		} else {
+			v184v2 = make(map[int]uint, len(v))
+		} // reset map
+		testUnmarshalErr(&v184v2, bs184, h, t, "dec-map-v184-p-len")
+		testDeepEqualErr(v184v1, v184v2, t, "equal-map-v184-p-len")
+		bs184 = testMarshalErr(&v184v1, h, t, "enc-map-v184-p")
+		v184v2 = nil
+		testUnmarshalErr(&v184v2, bs184, h, t, "dec-map-v184-p-nil")
+		testDeepEqualErr(v184v1, v184v2, t, "equal-map-v184-p-nil")
+		// ...
+		if v == nil {
+			v184v2 = nil
+		} else {
+			v184v2 = make(map[int]uint, len(v))
+		} // reset map
+		var v184v3, v184v4 typMapMapIntUint
+		v184v3 = typMapMapIntUint(v184v1)
+		v184v4 = typMapMapIntUint(v184v2)
+		bs184 = testMarshalErr(v184v3, h, t, "enc-map-v184-custom")
+		testUnmarshalErr(v184v4, bs184, h, t, "dec-map-v184-p-len")
+		testDeepEqualErr(v184v3, v184v4, t, "equal-map-v184-p-len")
+	}
+
+	for _, v := range []map[int]uint8{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v185: %v\n", v)
+		var v185v1, v185v2 map[int]uint8
+		v185v1 = v
+		bs185 := testMarshalErr(v185v1, h, t, "enc-map-v185")
+		if v == nil {
+			v185v2 = nil
+		} else {
+			v185v2 = make(map[int]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(v185v2, bs185, h, t, "dec-map-v185")
+		testDeepEqualErr(v185v1, v185v2, t, "equal-map-v185")
+		if v == nil {
+			v185v2 = nil
+		} else {
+			v185v2 = make(map[int]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v185v2), bs185, h, t, "dec-map-v185-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v185v1, v185v2, t, "equal-map-v185-noaddr")
+		if v == nil {
+			v185v2 = nil
+		} else {
+			v185v2 = make(map[int]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(&v185v2, bs185, h, t, "dec-map-v185-p-len")
+		testDeepEqualErr(v185v1, v185v2, t, "equal-map-v185-p-len")
+		bs185 = testMarshalErr(&v185v1, h, t, "enc-map-v185-p")
+		v185v2 = nil
+		testUnmarshalErr(&v185v2, bs185, h, t, "dec-map-v185-p-nil")
+		testDeepEqualErr(v185v1, v185v2, t, "equal-map-v185-p-nil")
+		// ...
+		if v == nil {
+			v185v2 = nil
+		} else {
+			v185v2 = make(map[int]uint8, len(v))
+		} // reset map
+		var v185v3, v185v4 typMapMapIntUint8
+		v185v3 = typMapMapIntUint8(v185v1)
+		v185v4 = typMapMapIntUint8(v185v2)
+		bs185 = testMarshalErr(v185v3, h, t, "enc-map-v185-custom")
+		testUnmarshalErr(v185v4, bs185, h, t, "dec-map-v185-p-len")
+		testDeepEqualErr(v185v3, v185v4, t, "equal-map-v185-p-len")
+	}
+
+	for _, v := range []map[int]uint16{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v186: %v\n", v)
+		var v186v1, v186v2 map[int]uint16
+		v186v1 = v
+		bs186 := testMarshalErr(v186v1, h, t, "enc-map-v186")
+		if v == nil {
+			v186v2 = nil
+		} else {
+			v186v2 = make(map[int]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(v186v2, bs186, h, t, "dec-map-v186")
+		testDeepEqualErr(v186v1, v186v2, t, "equal-map-v186")
+		if v == nil {
+			v186v2 = nil
+		} else {
+			v186v2 = make(map[int]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v186v2), bs186, h, t, "dec-map-v186-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v186v1, v186v2, t, "equal-map-v186-noaddr")
+		if v == nil {
+			v186v2 = nil
+		} else {
+			v186v2 = make(map[int]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(&v186v2, bs186, h, t, "dec-map-v186-p-len")
+		testDeepEqualErr(v186v1, v186v2, t, "equal-map-v186-p-len")
+		bs186 = testMarshalErr(&v186v1, h, t, "enc-map-v186-p")
+		v186v2 = nil
+		testUnmarshalErr(&v186v2, bs186, h, t, "dec-map-v186-p-nil")
+		testDeepEqualErr(v186v1, v186v2, t, "equal-map-v186-p-nil")
+		// ...
+		if v == nil {
+			v186v2 = nil
+		} else {
+			v186v2 = make(map[int]uint16, len(v))
+		} // reset map
+		var v186v3, v186v4 typMapMapIntUint16
+		v186v3 = typMapMapIntUint16(v186v1)
+		v186v4 = typMapMapIntUint16(v186v2)
+		bs186 = testMarshalErr(v186v3, h, t, "enc-map-v186-custom")
+		testUnmarshalErr(v186v4, bs186, h, t, "dec-map-v186-p-len")
+		testDeepEqualErr(v186v3, v186v4, t, "equal-map-v186-p-len")
+	}
+
+	for _, v := range []map[int]uint32{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v187: %v\n", v)
+		var v187v1, v187v2 map[int]uint32
+		v187v1 = v
+		bs187 := testMarshalErr(v187v1, h, t, "enc-map-v187")
+		if v == nil {
+			v187v2 = nil
+		} else {
+			v187v2 = make(map[int]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(v187v2, bs187, h, t, "dec-map-v187")
+		testDeepEqualErr(v187v1, v187v2, t, "equal-map-v187")
+		if v == nil {
+			v187v2 = nil
+		} else {
+			v187v2 = make(map[int]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v187v2), bs187, h, t, "dec-map-v187-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v187v1, v187v2, t, "equal-map-v187-noaddr")
+		if v == nil {
+			v187v2 = nil
+		} else {
+			v187v2 = make(map[int]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(&v187v2, bs187, h, t, "dec-map-v187-p-len")
+		testDeepEqualErr(v187v1, v187v2, t, "equal-map-v187-p-len")
+		bs187 = testMarshalErr(&v187v1, h, t, "enc-map-v187-p")
+		v187v2 = nil
+		testUnmarshalErr(&v187v2, bs187, h, t, "dec-map-v187-p-nil")
+		testDeepEqualErr(v187v1, v187v2, t, "equal-map-v187-p-nil")
+		// ...
+		if v == nil {
+			v187v2 = nil
+		} else {
+			v187v2 = make(map[int]uint32, len(v))
+		} // reset map
+		var v187v3, v187v4 typMapMapIntUint32
+		v187v3 = typMapMapIntUint32(v187v1)
+		v187v4 = typMapMapIntUint32(v187v2)
+		bs187 = testMarshalErr(v187v3, h, t, "enc-map-v187-custom")
+		testUnmarshalErr(v187v4, bs187, h, t, "dec-map-v187-p-len")
+		testDeepEqualErr(v187v3, v187v4, t, "equal-map-v187-p-len")
+	}
+
+	for _, v := range []map[int]uint64{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v188: %v\n", v)
+		var v188v1, v188v2 map[int]uint64
+		v188v1 = v
+		bs188 := testMarshalErr(v188v1, h, t, "enc-map-v188")
+		if v == nil {
+			v188v2 = nil
+		} else {
+			v188v2 = make(map[int]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(v188v2, bs188, h, t, "dec-map-v188")
+		testDeepEqualErr(v188v1, v188v2, t, "equal-map-v188")
+		if v == nil {
+			v188v2 = nil
+		} else {
+			v188v2 = make(map[int]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v188v2), bs188, h, t, "dec-map-v188-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v188v1, v188v2, t, "equal-map-v188-noaddr")
+		if v == nil {
+			v188v2 = nil
+		} else {
+			v188v2 = make(map[int]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(&v188v2, bs188, h, t, "dec-map-v188-p-len")
+		testDeepEqualErr(v188v1, v188v2, t, "equal-map-v188-p-len")
+		bs188 = testMarshalErr(&v188v1, h, t, "enc-map-v188-p")
+		v188v2 = nil
+		testUnmarshalErr(&v188v2, bs188, h, t, "dec-map-v188-p-nil")
+		testDeepEqualErr(v188v1, v188v2, t, "equal-map-v188-p-nil")
+		// ...
+		if v == nil {
+			v188v2 = nil
+		} else {
+			v188v2 = make(map[int]uint64, len(v))
+		} // reset map
+		var v188v3, v188v4 typMapMapIntUint64
+		v188v3 = typMapMapIntUint64(v188v1)
+		v188v4 = typMapMapIntUint64(v188v2)
+		bs188 = testMarshalErr(v188v3, h, t, "enc-map-v188-custom")
+		testUnmarshalErr(v188v4, bs188, h, t, "dec-map-v188-p-len")
+		testDeepEqualErr(v188v3, v188v4, t, "equal-map-v188-p-len")
+	}
+
+	for _, v := range []map[int]uintptr{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v189: %v\n", v)
+		var v189v1, v189v2 map[int]uintptr
+		v189v1 = v
+		bs189 := testMarshalErr(v189v1, h, t, "enc-map-v189")
+		if v == nil {
+			v189v2 = nil
+		} else {
+			v189v2 = make(map[int]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(v189v2, bs189, h, t, "dec-map-v189")
+		testDeepEqualErr(v189v1, v189v2, t, "equal-map-v189")
+		if v == nil {
+			v189v2 = nil
+		} else {
+			v189v2 = make(map[int]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v189v2), bs189, h, t, "dec-map-v189-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v189v1, v189v2, t, "equal-map-v189-noaddr")
+		if v == nil {
+			v189v2 = nil
+		} else {
+			v189v2 = make(map[int]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(&v189v2, bs189, h, t, "dec-map-v189-p-len")
+		testDeepEqualErr(v189v1, v189v2, t, "equal-map-v189-p-len")
+		bs189 = testMarshalErr(&v189v1, h, t, "enc-map-v189-p")
+		v189v2 = nil
+		testUnmarshalErr(&v189v2, bs189, h, t, "dec-map-v189-p-nil")
+		testDeepEqualErr(v189v1, v189v2, t, "equal-map-v189-p-nil")
+		// ...
+		if v == nil {
+			v189v2 = nil
+		} else {
+			v189v2 = make(map[int]uintptr, len(v))
+		} // reset map
+		var v189v3, v189v4 typMapMapIntUintptr
+		v189v3 = typMapMapIntUintptr(v189v1)
+		v189v4 = typMapMapIntUintptr(v189v2)
+		bs189 = testMarshalErr(v189v3, h, t, "enc-map-v189-custom")
+		testUnmarshalErr(v189v4, bs189, h, t, "dec-map-v189-p-len")
+		testDeepEqualErr(v189v3, v189v4, t, "equal-map-v189-p-len")
+	}
+
+	for _, v := range []map[int]int{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v190: %v\n", v)
+		var v190v1, v190v2 map[int]int
+		v190v1 = v
+		bs190 := testMarshalErr(v190v1, h, t, "enc-map-v190")
+		if v == nil {
+			v190v2 = nil
+		} else {
+			v190v2 = make(map[int]int, len(v))
+		} // reset map
+		testUnmarshalErr(v190v2, bs190, h, t, "dec-map-v190")
+		testDeepEqualErr(v190v1, v190v2, t, "equal-map-v190")
+		if v == nil {
+			v190v2 = nil
+		} else {
+			v190v2 = make(map[int]int, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v190v2), bs190, h, t, "dec-map-v190-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v190v1, v190v2, t, "equal-map-v190-noaddr")
+		if v == nil {
+			v190v2 = nil
+		} else {
+			v190v2 = make(map[int]int, len(v))
+		} // reset map
+		testUnmarshalErr(&v190v2, bs190, h, t, "dec-map-v190-p-len")
+		testDeepEqualErr(v190v1, v190v2, t, "equal-map-v190-p-len")
+		bs190 = testMarshalErr(&v190v1, h, t, "enc-map-v190-p")
+		v190v2 = nil
+		testUnmarshalErr(&v190v2, bs190, h, t, "dec-map-v190-p-nil")
+		testDeepEqualErr(v190v1, v190v2, t, "equal-map-v190-p-nil")
+		// ...
+		if v == nil {
+			v190v2 = nil
+		} else {
+			v190v2 = make(map[int]int, len(v))
+		} // reset map
+		var v190v3, v190v4 typMapMapIntInt
+		v190v3 = typMapMapIntInt(v190v1)
+		v190v4 = typMapMapIntInt(v190v2)
+		bs190 = testMarshalErr(v190v3, h, t, "enc-map-v190-custom")
+		testUnmarshalErr(v190v4, bs190, h, t, "dec-map-v190-p-len")
+		testDeepEqualErr(v190v3, v190v4, t, "equal-map-v190-p-len")
+	}
+
+	for _, v := range []map[int]int8{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v191: %v\n", v)
+		var v191v1, v191v2 map[int]int8
+		v191v1 = v
+		bs191 := testMarshalErr(v191v1, h, t, "enc-map-v191")
+		if v == nil {
+			v191v2 = nil
+		} else {
+			v191v2 = make(map[int]int8, len(v))
+		} // reset map
+		testUnmarshalErr(v191v2, bs191, h, t, "dec-map-v191")
+		testDeepEqualErr(v191v1, v191v2, t, "equal-map-v191")
+		if v == nil {
+			v191v2 = nil
+		} else {
+			v191v2 = make(map[int]int8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v191v2), bs191, h, t, "dec-map-v191-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v191v1, v191v2, t, "equal-map-v191-noaddr")
+		if v == nil {
+			v191v2 = nil
+		} else {
+			v191v2 = make(map[int]int8, len(v))
+		} // reset map
+		testUnmarshalErr(&v191v2, bs191, h, t, "dec-map-v191-p-len")
+		testDeepEqualErr(v191v1, v191v2, t, "equal-map-v191-p-len")
+		bs191 = testMarshalErr(&v191v1, h, t, "enc-map-v191-p")
+		v191v2 = nil
+		testUnmarshalErr(&v191v2, bs191, h, t, "dec-map-v191-p-nil")
+		testDeepEqualErr(v191v1, v191v2, t, "equal-map-v191-p-nil")
+		// ...
+		if v == nil {
+			v191v2 = nil
+		} else {
+			v191v2 = make(map[int]int8, len(v))
+		} // reset map
+		var v191v3, v191v4 typMapMapIntInt8
+		v191v3 = typMapMapIntInt8(v191v1)
+		v191v4 = typMapMapIntInt8(v191v2)
+		bs191 = testMarshalErr(v191v3, h, t, "enc-map-v191-custom")
+		testUnmarshalErr(v191v4, bs191, h, t, "dec-map-v191-p-len")
+		testDeepEqualErr(v191v3, v191v4, t, "equal-map-v191-p-len")
+	}
+
+	for _, v := range []map[int]int16{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v192: %v\n", v)
+		var v192v1, v192v2 map[int]int16
+		v192v1 = v
+		bs192 := testMarshalErr(v192v1, h, t, "enc-map-v192")
+		if v == nil {
+			v192v2 = nil
+		} else {
+			v192v2 = make(map[int]int16, len(v))
+		} // reset map
+		testUnmarshalErr(v192v2, bs192, h, t, "dec-map-v192")
+		testDeepEqualErr(v192v1, v192v2, t, "equal-map-v192")
+		if v == nil {
+			v192v2 = nil
+		} else {
+			v192v2 = make(map[int]int16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v192v2), bs192, h, t, "dec-map-v192-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v192v1, v192v2, t, "equal-map-v192-noaddr")
+		if v == nil {
+			v192v2 = nil
+		} else {
+			v192v2 = make(map[int]int16, len(v))
+		} // reset map
+		testUnmarshalErr(&v192v2, bs192, h, t, "dec-map-v192-p-len")
+		testDeepEqualErr(v192v1, v192v2, t, "equal-map-v192-p-len")
+		bs192 = testMarshalErr(&v192v1, h, t, "enc-map-v192-p")
+		v192v2 = nil
+		testUnmarshalErr(&v192v2, bs192, h, t, "dec-map-v192-p-nil")
+		testDeepEqualErr(v192v1, v192v2, t, "equal-map-v192-p-nil")
+		// ...
+		if v == nil {
+			v192v2 = nil
+		} else {
+			v192v2 = make(map[int]int16, len(v))
+		} // reset map
+		var v192v3, v192v4 typMapMapIntInt16
+		v192v3 = typMapMapIntInt16(v192v1)
+		v192v4 = typMapMapIntInt16(v192v2)
+		bs192 = testMarshalErr(v192v3, h, t, "enc-map-v192-custom")
+		testUnmarshalErr(v192v4, bs192, h, t, "dec-map-v192-p-len")
+		testDeepEqualErr(v192v3, v192v4, t, "equal-map-v192-p-len")
+	}
+
+	for _, v := range []map[int]int32{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v193: %v\n", v)
+		var v193v1, v193v2 map[int]int32
+		v193v1 = v
+		bs193 := testMarshalErr(v193v1, h, t, "enc-map-v193")
+		if v == nil {
+			v193v2 = nil
+		} else {
+			v193v2 = make(map[int]int32, len(v))
+		} // reset map
+		testUnmarshalErr(v193v2, bs193, h, t, "dec-map-v193")
+		testDeepEqualErr(v193v1, v193v2, t, "equal-map-v193")
+		if v == nil {
+			v193v2 = nil
+		} else {
+			v193v2 = make(map[int]int32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v193v2), bs193, h, t, "dec-map-v193-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v193v1, v193v2, t, "equal-map-v193-noaddr")
+		if v == nil {
+			v193v2 = nil
+		} else {
+			v193v2 = make(map[int]int32, len(v))
+		} // reset map
+		testUnmarshalErr(&v193v2, bs193, h, t, "dec-map-v193-p-len")
+		testDeepEqualErr(v193v1, v193v2, t, "equal-map-v193-p-len")
+		bs193 = testMarshalErr(&v193v1, h, t, "enc-map-v193-p")
+		v193v2 = nil
+		testUnmarshalErr(&v193v2, bs193, h, t, "dec-map-v193-p-nil")
+		testDeepEqualErr(v193v1, v193v2, t, "equal-map-v193-p-nil")
+		// ...
+		if v == nil {
+			v193v2 = nil
+		} else {
+			v193v2 = make(map[int]int32, len(v))
+		} // reset map
+		var v193v3, v193v4 typMapMapIntInt32
+		v193v3 = typMapMapIntInt32(v193v1)
+		v193v4 = typMapMapIntInt32(v193v2)
+		bs193 = testMarshalErr(v193v3, h, t, "enc-map-v193-custom")
+		testUnmarshalErr(v193v4, bs193, h, t, "dec-map-v193-p-len")
+		testDeepEqualErr(v193v3, v193v4, t, "equal-map-v193-p-len")
+	}
+
+	for _, v := range []map[int]int64{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v194: %v\n", v)
+		var v194v1, v194v2 map[int]int64
+		v194v1 = v
+		bs194 := testMarshalErr(v194v1, h, t, "enc-map-v194")
+		if v == nil {
+			v194v2 = nil
+		} else {
+			v194v2 = make(map[int]int64, len(v))
+		} // reset map
+		testUnmarshalErr(v194v2, bs194, h, t, "dec-map-v194")
+		testDeepEqualErr(v194v1, v194v2, t, "equal-map-v194")
+		if v == nil {
+			v194v2 = nil
+		} else {
+			v194v2 = make(map[int]int64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v194v2), bs194, h, t, "dec-map-v194-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v194v1, v194v2, t, "equal-map-v194-noaddr")
+		if v == nil {
+			v194v2 = nil
+		} else {
+			v194v2 = make(map[int]int64, len(v))
+		} // reset map
+		testUnmarshalErr(&v194v2, bs194, h, t, "dec-map-v194-p-len")
+		testDeepEqualErr(v194v1, v194v2, t, "equal-map-v194-p-len")
+		bs194 = testMarshalErr(&v194v1, h, t, "enc-map-v194-p")
+		v194v2 = nil
+		testUnmarshalErr(&v194v2, bs194, h, t, "dec-map-v194-p-nil")
+		testDeepEqualErr(v194v1, v194v2, t, "equal-map-v194-p-nil")
+		// ...
+		if v == nil {
+			v194v2 = nil
+		} else {
+			v194v2 = make(map[int]int64, len(v))
+		} // reset map
+		var v194v3, v194v4 typMapMapIntInt64
+		v194v3 = typMapMapIntInt64(v194v1)
+		v194v4 = typMapMapIntInt64(v194v2)
+		bs194 = testMarshalErr(v194v3, h, t, "enc-map-v194-custom")
+		testUnmarshalErr(v194v4, bs194, h, t, "dec-map-v194-p-len")
+		testDeepEqualErr(v194v3, v194v4, t, "equal-map-v194-p-len")
+	}
+
+	for _, v := range []map[int]float32{nil, {}, {33: 0, 44: 22.2}} {
+		// fmt.Printf(">>>> running mammoth map v195: %v\n", v)
+		var v195v1, v195v2 map[int]float32
+		v195v1 = v
+		bs195 := testMarshalErr(v195v1, h, t, "enc-map-v195")
+		if v == nil {
+			v195v2 = nil
+		} else {
+			v195v2 = make(map[int]float32, len(v))
+		} // reset map
+		testUnmarshalErr(v195v2, bs195, h, t, "dec-map-v195")
+		testDeepEqualErr(v195v1, v195v2, t, "equal-map-v195")
+		if v == nil {
+			v195v2 = nil
+		} else {
+			v195v2 = make(map[int]float32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v195v2), bs195, h, t, "dec-map-v195-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v195v1, v195v2, t, "equal-map-v195-noaddr")
+		if v == nil {
+			v195v2 = nil
+		} else {
+			v195v2 = make(map[int]float32, len(v))
+		} // reset map
+		testUnmarshalErr(&v195v2, bs195, h, t, "dec-map-v195-p-len")
+		testDeepEqualErr(v195v1, v195v2, t, "equal-map-v195-p-len")
+		bs195 = testMarshalErr(&v195v1, h, t, "enc-map-v195-p")
+		v195v2 = nil
+		testUnmarshalErr(&v195v2, bs195, h, t, "dec-map-v195-p-nil")
+		testDeepEqualErr(v195v1, v195v2, t, "equal-map-v195-p-nil")
+		// ...
+		if v == nil {
+			v195v2 = nil
+		} else {
+			v195v2 = make(map[int]float32, len(v))
+		} // reset map
+		var v195v3, v195v4 typMapMapIntFloat32
+		v195v3 = typMapMapIntFloat32(v195v1)
+		v195v4 = typMapMapIntFloat32(v195v2)
+		bs195 = testMarshalErr(v195v3, h, t, "enc-map-v195-custom")
+		testUnmarshalErr(v195v4, bs195, h, t, "dec-map-v195-p-len")
+		testDeepEqualErr(v195v3, v195v4, t, "equal-map-v195-p-len")
+	}
+
+	for _, v := range []map[int]float64{nil, {}, {33: 0, 44: 11.1}} {
+		// fmt.Printf(">>>> running mammoth map v196: %v\n", v)
+		var v196v1, v196v2 map[int]float64
+		v196v1 = v
+		bs196 := testMarshalErr(v196v1, h, t, "enc-map-v196")
+		if v == nil {
+			v196v2 = nil
+		} else {
+			v196v2 = make(map[int]float64, len(v))
+		} // reset map
+		testUnmarshalErr(v196v2, bs196, h, t, "dec-map-v196")
+		testDeepEqualErr(v196v1, v196v2, t, "equal-map-v196")
+		if v == nil {
+			v196v2 = nil
+		} else {
+			v196v2 = make(map[int]float64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v196v2), bs196, h, t, "dec-map-v196-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v196v1, v196v2, t, "equal-map-v196-noaddr")
+		if v == nil {
+			v196v2 = nil
+		} else {
+			v196v2 = make(map[int]float64, len(v))
+		} // reset map
+		testUnmarshalErr(&v196v2, bs196, h, t, "dec-map-v196-p-len")
+		testDeepEqualErr(v196v1, v196v2, t, "equal-map-v196-p-len")
+		bs196 = testMarshalErr(&v196v1, h, t, "enc-map-v196-p")
+		v196v2 = nil
+		testUnmarshalErr(&v196v2, bs196, h, t, "dec-map-v196-p-nil")
+		testDeepEqualErr(v196v1, v196v2, t, "equal-map-v196-p-nil")
+		// ...
+		if v == nil {
+			v196v2 = nil
+		} else {
+			v196v2 = make(map[int]float64, len(v))
+		} // reset map
+		var v196v3, v196v4 typMapMapIntFloat64
+		v196v3 = typMapMapIntFloat64(v196v1)
+		v196v4 = typMapMapIntFloat64(v196v2)
+		bs196 = testMarshalErr(v196v3, h, t, "enc-map-v196-custom")
+		testUnmarshalErr(v196v4, bs196, h, t, "dec-map-v196-p-len")
+		testDeepEqualErr(v196v3, v196v4, t, "equal-map-v196-p-len")
+	}
+
+	for _, v := range []map[int]bool{nil, {}, {33: false, 44: true}} {
+		// fmt.Printf(">>>> running mammoth map v197: %v\n", v)
+		var v197v1, v197v2 map[int]bool
+		v197v1 = v
+		bs197 := testMarshalErr(v197v1, h, t, "enc-map-v197")
+		if v == nil {
+			v197v2 = nil
+		} else {
+			v197v2 = make(map[int]bool, len(v))
+		} // reset map
+		testUnmarshalErr(v197v2, bs197, h, t, "dec-map-v197")
+		testDeepEqualErr(v197v1, v197v2, t, "equal-map-v197")
+		if v == nil {
+			v197v2 = nil
+		} else {
+			v197v2 = make(map[int]bool, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v197v2), bs197, h, t, "dec-map-v197-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v197v1, v197v2, t, "equal-map-v197-noaddr")
+		if v == nil {
+			v197v2 = nil
+		} else {
+			v197v2 = make(map[int]bool, len(v))
+		} // reset map
+		testUnmarshalErr(&v197v2, bs197, h, t, "dec-map-v197-p-len")
+		testDeepEqualErr(v197v1, v197v2, t, "equal-map-v197-p-len")
+		bs197 = testMarshalErr(&v197v1, h, t, "enc-map-v197-p")
+		v197v2 = nil
+		testUnmarshalErr(&v197v2, bs197, h, t, "dec-map-v197-p-nil")
+		testDeepEqualErr(v197v1, v197v2, t, "equal-map-v197-p-nil")
+		// ...
+		if v == nil {
+			v197v2 = nil
+		} else {
+			v197v2 = make(map[int]bool, len(v))
+		} // reset map
+		var v197v3, v197v4 typMapMapIntBool
+		v197v3 = typMapMapIntBool(v197v1)
+		v197v4 = typMapMapIntBool(v197v2)
+		bs197 = testMarshalErr(v197v3, h, t, "enc-map-v197-custom")
+		testUnmarshalErr(v197v4, bs197, h, t, "dec-map-v197-p-len")
+		testDeepEqualErr(v197v3, v197v4, t, "equal-map-v197-p-len")
+	}
+
+	for _, v := range []map[int8]interface{}{nil, {}, {33: nil, 44: "string-is-an-interface"}} {
+		// fmt.Printf(">>>> running mammoth map v200: %v\n", v)
+		var v200v1, v200v2 map[int8]interface{}
+		v200v1 = v
+		bs200 := testMarshalErr(v200v1, h, t, "enc-map-v200")
+		if v == nil {
+			v200v2 = nil
+		} else {
+			v200v2 = make(map[int8]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(v200v2, bs200, h, t, "dec-map-v200")
+		testDeepEqualErr(v200v1, v200v2, t, "equal-map-v200")
+		if v == nil {
+			v200v2 = nil
+		} else {
+			v200v2 = make(map[int8]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v200v2), bs200, h, t, "dec-map-v200-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v200v1, v200v2, t, "equal-map-v200-noaddr")
+		if v == nil {
+			v200v2 = nil
+		} else {
+			v200v2 = make(map[int8]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(&v200v2, bs200, h, t, "dec-map-v200-p-len")
+		testDeepEqualErr(v200v1, v200v2, t, "equal-map-v200-p-len")
+		bs200 = testMarshalErr(&v200v1, h, t, "enc-map-v200-p")
+		v200v2 = nil
+		testUnmarshalErr(&v200v2, bs200, h, t, "dec-map-v200-p-nil")
+		testDeepEqualErr(v200v1, v200v2, t, "equal-map-v200-p-nil")
+		// ...
+		if v == nil {
+			v200v2 = nil
+		} else {
+			v200v2 = make(map[int8]interface{}, len(v))
+		} // reset map
+		var v200v3, v200v4 typMapMapInt8Intf
+		v200v3 = typMapMapInt8Intf(v200v1)
+		v200v4 = typMapMapInt8Intf(v200v2)
+		bs200 = testMarshalErr(v200v3, h, t, "enc-map-v200-custom")
+		testUnmarshalErr(v200v4, bs200, h, t, "dec-map-v200-p-len")
+		testDeepEqualErr(v200v3, v200v4, t, "equal-map-v200-p-len")
+	}
+
+	for _, v := range []map[int8]string{nil, {}, {33: "", 44: "some-string"}} {
+		// fmt.Printf(">>>> running mammoth map v201: %v\n", v)
+		var v201v1, v201v2 map[int8]string
+		v201v1 = v
+		bs201 := testMarshalErr(v201v1, h, t, "enc-map-v201")
+		if v == nil {
+			v201v2 = nil
+		} else {
+			v201v2 = make(map[int8]string, len(v))
+		} // reset map
+		testUnmarshalErr(v201v2, bs201, h, t, "dec-map-v201")
+		testDeepEqualErr(v201v1, v201v2, t, "equal-map-v201")
+		if v == nil {
+			v201v2 = nil
+		} else {
+			v201v2 = make(map[int8]string, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v201v2), bs201, h, t, "dec-map-v201-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v201v1, v201v2, t, "equal-map-v201-noaddr")
+		if v == nil {
+			v201v2 = nil
+		} else {
+			v201v2 = make(map[int8]string, len(v))
+		} // reset map
+		testUnmarshalErr(&v201v2, bs201, h, t, "dec-map-v201-p-len")
+		testDeepEqualErr(v201v1, v201v2, t, "equal-map-v201-p-len")
+		bs201 = testMarshalErr(&v201v1, h, t, "enc-map-v201-p")
+		v201v2 = nil
+		testUnmarshalErr(&v201v2, bs201, h, t, "dec-map-v201-p-nil")
+		testDeepEqualErr(v201v1, v201v2, t, "equal-map-v201-p-nil")
+		// ...
+		if v == nil {
+			v201v2 = nil
+		} else {
+			v201v2 = make(map[int8]string, len(v))
+		} // reset map
+		var v201v3, v201v4 typMapMapInt8String
+		v201v3 = typMapMapInt8String(v201v1)
+		v201v4 = typMapMapInt8String(v201v2)
+		bs201 = testMarshalErr(v201v3, h, t, "enc-map-v201-custom")
+		testUnmarshalErr(v201v4, bs201, h, t, "dec-map-v201-p-len")
+		testDeepEqualErr(v201v3, v201v4, t, "equal-map-v201-p-len")
+	}
+
+	for _, v := range []map[int8]uint{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v202: %v\n", v)
+		var v202v1, v202v2 map[int8]uint
+		v202v1 = v
+		bs202 := testMarshalErr(v202v1, h, t, "enc-map-v202")
+		if v == nil {
+			v202v2 = nil
+		} else {
+			v202v2 = make(map[int8]uint, len(v))
+		} // reset map
+		testUnmarshalErr(v202v2, bs202, h, t, "dec-map-v202")
+		testDeepEqualErr(v202v1, v202v2, t, "equal-map-v202")
+		if v == nil {
+			v202v2 = nil
+		} else {
+			v202v2 = make(map[int8]uint, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v202v2), bs202, h, t, "dec-map-v202-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v202v1, v202v2, t, "equal-map-v202-noaddr")
+		if v == nil {
+			v202v2 = nil
+		} else {
+			v202v2 = make(map[int8]uint, len(v))
+		} // reset map
+		testUnmarshalErr(&v202v2, bs202, h, t, "dec-map-v202-p-len")
+		testDeepEqualErr(v202v1, v202v2, t, "equal-map-v202-p-len")
+		bs202 = testMarshalErr(&v202v1, h, t, "enc-map-v202-p")
+		v202v2 = nil
+		testUnmarshalErr(&v202v2, bs202, h, t, "dec-map-v202-p-nil")
+		testDeepEqualErr(v202v1, v202v2, t, "equal-map-v202-p-nil")
+		// ...
+		if v == nil {
+			v202v2 = nil
+		} else {
+			v202v2 = make(map[int8]uint, len(v))
+		} // reset map
+		var v202v3, v202v4 typMapMapInt8Uint
+		v202v3 = typMapMapInt8Uint(v202v1)
+		v202v4 = typMapMapInt8Uint(v202v2)
+		bs202 = testMarshalErr(v202v3, h, t, "enc-map-v202-custom")
+		testUnmarshalErr(v202v4, bs202, h, t, "dec-map-v202-p-len")
+		testDeepEqualErr(v202v3, v202v4, t, "equal-map-v202-p-len")
+	}
+
+	for _, v := range []map[int8]uint8{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v203: %v\n", v)
+		var v203v1, v203v2 map[int8]uint8
+		v203v1 = v
+		bs203 := testMarshalErr(v203v1, h, t, "enc-map-v203")
+		if v == nil {
+			v203v2 = nil
+		} else {
+			v203v2 = make(map[int8]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(v203v2, bs203, h, t, "dec-map-v203")
+		testDeepEqualErr(v203v1, v203v2, t, "equal-map-v203")
+		if v == nil {
+			v203v2 = nil
+		} else {
+			v203v2 = make(map[int8]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v203v2), bs203, h, t, "dec-map-v203-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v203v1, v203v2, t, "equal-map-v203-noaddr")
+		if v == nil {
+			v203v2 = nil
+		} else {
+			v203v2 = make(map[int8]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(&v203v2, bs203, h, t, "dec-map-v203-p-len")
+		testDeepEqualErr(v203v1, v203v2, t, "equal-map-v203-p-len")
+		bs203 = testMarshalErr(&v203v1, h, t, "enc-map-v203-p")
+		v203v2 = nil
+		testUnmarshalErr(&v203v2, bs203, h, t, "dec-map-v203-p-nil")
+		testDeepEqualErr(v203v1, v203v2, t, "equal-map-v203-p-nil")
+		// ...
+		if v == nil {
+			v203v2 = nil
+		} else {
+			v203v2 = make(map[int8]uint8, len(v))
+		} // reset map
+		var v203v3, v203v4 typMapMapInt8Uint8
+		v203v3 = typMapMapInt8Uint8(v203v1)
+		v203v4 = typMapMapInt8Uint8(v203v2)
+		bs203 = testMarshalErr(v203v3, h, t, "enc-map-v203-custom")
+		testUnmarshalErr(v203v4, bs203, h, t, "dec-map-v203-p-len")
+		testDeepEqualErr(v203v3, v203v4, t, "equal-map-v203-p-len")
+	}
+
+	for _, v := range []map[int8]uint16{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v204: %v\n", v)
+		var v204v1, v204v2 map[int8]uint16
+		v204v1 = v
+		bs204 := testMarshalErr(v204v1, h, t, "enc-map-v204")
+		if v == nil {
+			v204v2 = nil
+		} else {
+			v204v2 = make(map[int8]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(v204v2, bs204, h, t, "dec-map-v204")
+		testDeepEqualErr(v204v1, v204v2, t, "equal-map-v204")
+		if v == nil {
+			v204v2 = nil
+		} else {
+			v204v2 = make(map[int8]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v204v2), bs204, h, t, "dec-map-v204-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v204v1, v204v2, t, "equal-map-v204-noaddr")
+		if v == nil {
+			v204v2 = nil
+		} else {
+			v204v2 = make(map[int8]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(&v204v2, bs204, h, t, "dec-map-v204-p-len")
+		testDeepEqualErr(v204v1, v204v2, t, "equal-map-v204-p-len")
+		bs204 = testMarshalErr(&v204v1, h, t, "enc-map-v204-p")
+		v204v2 = nil
+		testUnmarshalErr(&v204v2, bs204, h, t, "dec-map-v204-p-nil")
+		testDeepEqualErr(v204v1, v204v2, t, "equal-map-v204-p-nil")
+		// ...
+		if v == nil {
+			v204v2 = nil
+		} else {
+			v204v2 = make(map[int8]uint16, len(v))
+		} // reset map
+		var v204v3, v204v4 typMapMapInt8Uint16
+		v204v3 = typMapMapInt8Uint16(v204v1)
+		v204v4 = typMapMapInt8Uint16(v204v2)
+		bs204 = testMarshalErr(v204v3, h, t, "enc-map-v204-custom")
+		testUnmarshalErr(v204v4, bs204, h, t, "dec-map-v204-p-len")
+		testDeepEqualErr(v204v3, v204v4, t, "equal-map-v204-p-len")
+	}
+
+	for _, v := range []map[int8]uint32{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v205: %v\n", v)
+		var v205v1, v205v2 map[int8]uint32
+		v205v1 = v
+		bs205 := testMarshalErr(v205v1, h, t, "enc-map-v205")
+		if v == nil {
+			v205v2 = nil
+		} else {
+			v205v2 = make(map[int8]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(v205v2, bs205, h, t, "dec-map-v205")
+		testDeepEqualErr(v205v1, v205v2, t, "equal-map-v205")
+		if v == nil {
+			v205v2 = nil
+		} else {
+			v205v2 = make(map[int8]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v205v2), bs205, h, t, "dec-map-v205-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v205v1, v205v2, t, "equal-map-v205-noaddr")
+		if v == nil {
+			v205v2 = nil
+		} else {
+			v205v2 = make(map[int8]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(&v205v2, bs205, h, t, "dec-map-v205-p-len")
+		testDeepEqualErr(v205v1, v205v2, t, "equal-map-v205-p-len")
+		bs205 = testMarshalErr(&v205v1, h, t, "enc-map-v205-p")
+		v205v2 = nil
+		testUnmarshalErr(&v205v2, bs205, h, t, "dec-map-v205-p-nil")
+		testDeepEqualErr(v205v1, v205v2, t, "equal-map-v205-p-nil")
+		// ...
+		if v == nil {
+			v205v2 = nil
+		} else {
+			v205v2 = make(map[int8]uint32, len(v))
+		} // reset map
+		var v205v3, v205v4 typMapMapInt8Uint32
+		v205v3 = typMapMapInt8Uint32(v205v1)
+		v205v4 = typMapMapInt8Uint32(v205v2)
+		bs205 = testMarshalErr(v205v3, h, t, "enc-map-v205-custom")
+		testUnmarshalErr(v205v4, bs205, h, t, "dec-map-v205-p-len")
+		testDeepEqualErr(v205v3, v205v4, t, "equal-map-v205-p-len")
+	}
+
+	for _, v := range []map[int8]uint64{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v206: %v\n", v)
+		var v206v1, v206v2 map[int8]uint64
+		v206v1 = v
+		bs206 := testMarshalErr(v206v1, h, t, "enc-map-v206")
+		if v == nil {
+			v206v2 = nil
+		} else {
+			v206v2 = make(map[int8]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(v206v2, bs206, h, t, "dec-map-v206")
+		testDeepEqualErr(v206v1, v206v2, t, "equal-map-v206")
+		if v == nil {
+			v206v2 = nil
+		} else {
+			v206v2 = make(map[int8]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v206v2), bs206, h, t, "dec-map-v206-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v206v1, v206v2, t, "equal-map-v206-noaddr")
+		if v == nil {
+			v206v2 = nil
+		} else {
+			v206v2 = make(map[int8]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(&v206v2, bs206, h, t, "dec-map-v206-p-len")
+		testDeepEqualErr(v206v1, v206v2, t, "equal-map-v206-p-len")
+		bs206 = testMarshalErr(&v206v1, h, t, "enc-map-v206-p")
+		v206v2 = nil
+		testUnmarshalErr(&v206v2, bs206, h, t, "dec-map-v206-p-nil")
+		testDeepEqualErr(v206v1, v206v2, t, "equal-map-v206-p-nil")
+		// ...
+		if v == nil {
+			v206v2 = nil
+		} else {
+			v206v2 = make(map[int8]uint64, len(v))
+		} // reset map
+		var v206v3, v206v4 typMapMapInt8Uint64
+		v206v3 = typMapMapInt8Uint64(v206v1)
+		v206v4 = typMapMapInt8Uint64(v206v2)
+		bs206 = testMarshalErr(v206v3, h, t, "enc-map-v206-custom")
+		testUnmarshalErr(v206v4, bs206, h, t, "dec-map-v206-p-len")
+		testDeepEqualErr(v206v3, v206v4, t, "equal-map-v206-p-len")
+	}
+
+	for _, v := range []map[int8]uintptr{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v207: %v\n", v)
+		var v207v1, v207v2 map[int8]uintptr
+		v207v1 = v
+		bs207 := testMarshalErr(v207v1, h, t, "enc-map-v207")
+		if v == nil {
+			v207v2 = nil
+		} else {
+			v207v2 = make(map[int8]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(v207v2, bs207, h, t, "dec-map-v207")
+		testDeepEqualErr(v207v1, v207v2, t, "equal-map-v207")
+		if v == nil {
+			v207v2 = nil
+		} else {
+			v207v2 = make(map[int8]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v207v2), bs207, h, t, "dec-map-v207-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v207v1, v207v2, t, "equal-map-v207-noaddr")
+		if v == nil {
+			v207v2 = nil
+		} else {
+			v207v2 = make(map[int8]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(&v207v2, bs207, h, t, "dec-map-v207-p-len")
+		testDeepEqualErr(v207v1, v207v2, t, "equal-map-v207-p-len")
+		bs207 = testMarshalErr(&v207v1, h, t, "enc-map-v207-p")
+		v207v2 = nil
+		testUnmarshalErr(&v207v2, bs207, h, t, "dec-map-v207-p-nil")
+		testDeepEqualErr(v207v1, v207v2, t, "equal-map-v207-p-nil")
+		// ...
+		if v == nil {
+			v207v2 = nil
+		} else {
+			v207v2 = make(map[int8]uintptr, len(v))
+		} // reset map
+		var v207v3, v207v4 typMapMapInt8Uintptr
+		v207v3 = typMapMapInt8Uintptr(v207v1)
+		v207v4 = typMapMapInt8Uintptr(v207v2)
+		bs207 = testMarshalErr(v207v3, h, t, "enc-map-v207-custom")
+		testUnmarshalErr(v207v4, bs207, h, t, "dec-map-v207-p-len")
+		testDeepEqualErr(v207v3, v207v4, t, "equal-map-v207-p-len")
+	}
+
+	for _, v := range []map[int8]int{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v208: %v\n", v)
+		var v208v1, v208v2 map[int8]int
+		v208v1 = v
+		bs208 := testMarshalErr(v208v1, h, t, "enc-map-v208")
+		if v == nil {
+			v208v2 = nil
+		} else {
+			v208v2 = make(map[int8]int, len(v))
+		} // reset map
+		testUnmarshalErr(v208v2, bs208, h, t, "dec-map-v208")
+		testDeepEqualErr(v208v1, v208v2, t, "equal-map-v208")
+		if v == nil {
+			v208v2 = nil
+		} else {
+			v208v2 = make(map[int8]int, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v208v2), bs208, h, t, "dec-map-v208-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v208v1, v208v2, t, "equal-map-v208-noaddr")
+		if v == nil {
+			v208v2 = nil
+		} else {
+			v208v2 = make(map[int8]int, len(v))
+		} // reset map
+		testUnmarshalErr(&v208v2, bs208, h, t, "dec-map-v208-p-len")
+		testDeepEqualErr(v208v1, v208v2, t, "equal-map-v208-p-len")
+		bs208 = testMarshalErr(&v208v1, h, t, "enc-map-v208-p")
+		v208v2 = nil
+		testUnmarshalErr(&v208v2, bs208, h, t, "dec-map-v208-p-nil")
+		testDeepEqualErr(v208v1, v208v2, t, "equal-map-v208-p-nil")
+		// ...
+		if v == nil {
+			v208v2 = nil
+		} else {
+			v208v2 = make(map[int8]int, len(v))
+		} // reset map
+		var v208v3, v208v4 typMapMapInt8Int
+		v208v3 = typMapMapInt8Int(v208v1)
+		v208v4 = typMapMapInt8Int(v208v2)
+		bs208 = testMarshalErr(v208v3, h, t, "enc-map-v208-custom")
+		testUnmarshalErr(v208v4, bs208, h, t, "dec-map-v208-p-len")
+		testDeepEqualErr(v208v3, v208v4, t, "equal-map-v208-p-len")
+	}
+
+	for _, v := range []map[int8]int8{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v209: %v\n", v)
+		var v209v1, v209v2 map[int8]int8
+		v209v1 = v
+		bs209 := testMarshalErr(v209v1, h, t, "enc-map-v209")
+		if v == nil {
+			v209v2 = nil
+		} else {
+			v209v2 = make(map[int8]int8, len(v))
+		} // reset map
+		testUnmarshalErr(v209v2, bs209, h, t, "dec-map-v209")
+		testDeepEqualErr(v209v1, v209v2, t, "equal-map-v209")
+		if v == nil {
+			v209v2 = nil
+		} else {
+			v209v2 = make(map[int8]int8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v209v2), bs209, h, t, "dec-map-v209-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v209v1, v209v2, t, "equal-map-v209-noaddr")
+		if v == nil {
+			v209v2 = nil
+		} else {
+			v209v2 = make(map[int8]int8, len(v))
+		} // reset map
+		testUnmarshalErr(&v209v2, bs209, h, t, "dec-map-v209-p-len")
+		testDeepEqualErr(v209v1, v209v2, t, "equal-map-v209-p-len")
+		bs209 = testMarshalErr(&v209v1, h, t, "enc-map-v209-p")
+		v209v2 = nil
+		testUnmarshalErr(&v209v2, bs209, h, t, "dec-map-v209-p-nil")
+		testDeepEqualErr(v209v1, v209v2, t, "equal-map-v209-p-nil")
+		// ...
+		if v == nil {
+			v209v2 = nil
+		} else {
+			v209v2 = make(map[int8]int8, len(v))
+		} // reset map
+		var v209v3, v209v4 typMapMapInt8Int8
+		v209v3 = typMapMapInt8Int8(v209v1)
+		v209v4 = typMapMapInt8Int8(v209v2)
+		bs209 = testMarshalErr(v209v3, h, t, "enc-map-v209-custom")
+		testUnmarshalErr(v209v4, bs209, h, t, "dec-map-v209-p-len")
+		testDeepEqualErr(v209v3, v209v4, t, "equal-map-v209-p-len")
+	}
+
+	for _, v := range []map[int8]int16{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v210: %v\n", v)
+		var v210v1, v210v2 map[int8]int16
+		v210v1 = v
+		bs210 := testMarshalErr(v210v1, h, t, "enc-map-v210")
+		if v == nil {
+			v210v2 = nil
+		} else {
+			v210v2 = make(map[int8]int16, len(v))
+		} // reset map
+		testUnmarshalErr(v210v2, bs210, h, t, "dec-map-v210")
+		testDeepEqualErr(v210v1, v210v2, t, "equal-map-v210")
+		if v == nil {
+			v210v2 = nil
+		} else {
+			v210v2 = make(map[int8]int16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v210v2), bs210, h, t, "dec-map-v210-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v210v1, v210v2, t, "equal-map-v210-noaddr")
+		if v == nil {
+			v210v2 = nil
+		} else {
+			v210v2 = make(map[int8]int16, len(v))
+		} // reset map
+		testUnmarshalErr(&v210v2, bs210, h, t, "dec-map-v210-p-len")
+		testDeepEqualErr(v210v1, v210v2, t, "equal-map-v210-p-len")
+		bs210 = testMarshalErr(&v210v1, h, t, "enc-map-v210-p")
+		v210v2 = nil
+		testUnmarshalErr(&v210v2, bs210, h, t, "dec-map-v210-p-nil")
+		testDeepEqualErr(v210v1, v210v2, t, "equal-map-v210-p-nil")
+		// ...
+		if v == nil {
+			v210v2 = nil
+		} else {
+			v210v2 = make(map[int8]int16, len(v))
+		} // reset map
+		var v210v3, v210v4 typMapMapInt8Int16
+		v210v3 = typMapMapInt8Int16(v210v1)
+		v210v4 = typMapMapInt8Int16(v210v2)
+		bs210 = testMarshalErr(v210v3, h, t, "enc-map-v210-custom")
+		testUnmarshalErr(v210v4, bs210, h, t, "dec-map-v210-p-len")
+		testDeepEqualErr(v210v3, v210v4, t, "equal-map-v210-p-len")
+	}
+
+	for _, v := range []map[int8]int32{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v211: %v\n", v)
+		var v211v1, v211v2 map[int8]int32
+		v211v1 = v
+		bs211 := testMarshalErr(v211v1, h, t, "enc-map-v211")
+		if v == nil {
+			v211v2 = nil
+		} else {
+			v211v2 = make(map[int8]int32, len(v))
+		} // reset map
+		testUnmarshalErr(v211v2, bs211, h, t, "dec-map-v211")
+		testDeepEqualErr(v211v1, v211v2, t, "equal-map-v211")
+		if v == nil {
+			v211v2 = nil
+		} else {
+			v211v2 = make(map[int8]int32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v211v2), bs211, h, t, "dec-map-v211-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v211v1, v211v2, t, "equal-map-v211-noaddr")
+		if v == nil {
+			v211v2 = nil
+		} else {
+			v211v2 = make(map[int8]int32, len(v))
+		} // reset map
+		testUnmarshalErr(&v211v2, bs211, h, t, "dec-map-v211-p-len")
+		testDeepEqualErr(v211v1, v211v2, t, "equal-map-v211-p-len")
+		bs211 = testMarshalErr(&v211v1, h, t, "enc-map-v211-p")
+		v211v2 = nil
+		testUnmarshalErr(&v211v2, bs211, h, t, "dec-map-v211-p-nil")
+		testDeepEqualErr(v211v1, v211v2, t, "equal-map-v211-p-nil")
+		// ...
+		if v == nil {
+			v211v2 = nil
+		} else {
+			v211v2 = make(map[int8]int32, len(v))
+		} // reset map
+		var v211v3, v211v4 typMapMapInt8Int32
+		v211v3 = typMapMapInt8Int32(v211v1)
+		v211v4 = typMapMapInt8Int32(v211v2)
+		bs211 = testMarshalErr(v211v3, h, t, "enc-map-v211-custom")
+		testUnmarshalErr(v211v4, bs211, h, t, "dec-map-v211-p-len")
+		testDeepEqualErr(v211v3, v211v4, t, "equal-map-v211-p-len")
+	}
+
+	for _, v := range []map[int8]int64{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v212: %v\n", v)
+		var v212v1, v212v2 map[int8]int64
+		v212v1 = v
+		bs212 := testMarshalErr(v212v1, h, t, "enc-map-v212")
+		if v == nil {
+			v212v2 = nil
+		} else {
+			v212v2 = make(map[int8]int64, len(v))
+		} // reset map
+		testUnmarshalErr(v212v2, bs212, h, t, "dec-map-v212")
+		testDeepEqualErr(v212v1, v212v2, t, "equal-map-v212")
+		if v == nil {
+			v212v2 = nil
+		} else {
+			v212v2 = make(map[int8]int64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v212v2), bs212, h, t, "dec-map-v212-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v212v1, v212v2, t, "equal-map-v212-noaddr")
+		if v == nil {
+			v212v2 = nil
+		} else {
+			v212v2 = make(map[int8]int64, len(v))
+		} // reset map
+		testUnmarshalErr(&v212v2, bs212, h, t, "dec-map-v212-p-len")
+		testDeepEqualErr(v212v1, v212v2, t, "equal-map-v212-p-len")
+		bs212 = testMarshalErr(&v212v1, h, t, "enc-map-v212-p")
+		v212v2 = nil
+		testUnmarshalErr(&v212v2, bs212, h, t, "dec-map-v212-p-nil")
+		testDeepEqualErr(v212v1, v212v2, t, "equal-map-v212-p-nil")
+		// ...
+		if v == nil {
+			v212v2 = nil
+		} else {
+			v212v2 = make(map[int8]int64, len(v))
+		} // reset map
+		var v212v3, v212v4 typMapMapInt8Int64
+		v212v3 = typMapMapInt8Int64(v212v1)
+		v212v4 = typMapMapInt8Int64(v212v2)
+		bs212 = testMarshalErr(v212v3, h, t, "enc-map-v212-custom")
+		testUnmarshalErr(v212v4, bs212, h, t, "dec-map-v212-p-len")
+		testDeepEqualErr(v212v3, v212v4, t, "equal-map-v212-p-len")
+	}
+
+	for _, v := range []map[int8]float32{nil, {}, {44: 0, 33: 22.2}} {
+		// fmt.Printf(">>>> running mammoth map v213: %v\n", v)
+		var v213v1, v213v2 map[int8]float32
+		v213v1 = v
+		bs213 := testMarshalErr(v213v1, h, t, "enc-map-v213")
+		if v == nil {
+			v213v2 = nil
+		} else {
+			v213v2 = make(map[int8]float32, len(v))
+		} // reset map
+		testUnmarshalErr(v213v2, bs213, h, t, "dec-map-v213")
+		testDeepEqualErr(v213v1, v213v2, t, "equal-map-v213")
+		if v == nil {
+			v213v2 = nil
+		} else {
+			v213v2 = make(map[int8]float32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v213v2), bs213, h, t, "dec-map-v213-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v213v1, v213v2, t, "equal-map-v213-noaddr")
+		if v == nil {
+			v213v2 = nil
+		} else {
+			v213v2 = make(map[int8]float32, len(v))
+		} // reset map
+		testUnmarshalErr(&v213v2, bs213, h, t, "dec-map-v213-p-len")
+		testDeepEqualErr(v213v1, v213v2, t, "equal-map-v213-p-len")
+		bs213 = testMarshalErr(&v213v1, h, t, "enc-map-v213-p")
+		v213v2 = nil
+		testUnmarshalErr(&v213v2, bs213, h, t, "dec-map-v213-p-nil")
+		testDeepEqualErr(v213v1, v213v2, t, "equal-map-v213-p-nil")
+		// ...
+		if v == nil {
+			v213v2 = nil
+		} else {
+			v213v2 = make(map[int8]float32, len(v))
+		} // reset map
+		var v213v3, v213v4 typMapMapInt8Float32
+		v213v3 = typMapMapInt8Float32(v213v1)
+		v213v4 = typMapMapInt8Float32(v213v2)
+		bs213 = testMarshalErr(v213v3, h, t, "enc-map-v213-custom")
+		testUnmarshalErr(v213v4, bs213, h, t, "dec-map-v213-p-len")
+		testDeepEqualErr(v213v3, v213v4, t, "equal-map-v213-p-len")
+	}
+
+	for _, v := range []map[int8]float64{nil, {}, {44: 0, 33: 11.1}} {
+		// fmt.Printf(">>>> running mammoth map v214: %v\n", v)
+		var v214v1, v214v2 map[int8]float64
+		v214v1 = v
+		bs214 := testMarshalErr(v214v1, h, t, "enc-map-v214")
+		if v == nil {
+			v214v2 = nil
+		} else {
+			v214v2 = make(map[int8]float64, len(v))
+		} // reset map
+		testUnmarshalErr(v214v2, bs214, h, t, "dec-map-v214")
+		testDeepEqualErr(v214v1, v214v2, t, "equal-map-v214")
+		if v == nil {
+			v214v2 = nil
+		} else {
+			v214v2 = make(map[int8]float64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v214v2), bs214, h, t, "dec-map-v214-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v214v1, v214v2, t, "equal-map-v214-noaddr")
+		if v == nil {
+			v214v2 = nil
+		} else {
+			v214v2 = make(map[int8]float64, len(v))
+		} // reset map
+		testUnmarshalErr(&v214v2, bs214, h, t, "dec-map-v214-p-len")
+		testDeepEqualErr(v214v1, v214v2, t, "equal-map-v214-p-len")
+		bs214 = testMarshalErr(&v214v1, h, t, "enc-map-v214-p")
+		v214v2 = nil
+		testUnmarshalErr(&v214v2, bs214, h, t, "dec-map-v214-p-nil")
+		testDeepEqualErr(v214v1, v214v2, t, "equal-map-v214-p-nil")
+		// ...
+		if v == nil {
+			v214v2 = nil
+		} else {
+			v214v2 = make(map[int8]float64, len(v))
+		} // reset map
+		var v214v3, v214v4 typMapMapInt8Float64
+		v214v3 = typMapMapInt8Float64(v214v1)
+		v214v4 = typMapMapInt8Float64(v214v2)
+		bs214 = testMarshalErr(v214v3, h, t, "enc-map-v214-custom")
+		testUnmarshalErr(v214v4, bs214, h, t, "dec-map-v214-p-len")
+		testDeepEqualErr(v214v3, v214v4, t, "equal-map-v214-p-len")
+	}
+
+	for _, v := range []map[int8]bool{nil, {}, {44: false, 33: true}} {
+		// fmt.Printf(">>>> running mammoth map v215: %v\n", v)
+		var v215v1, v215v2 map[int8]bool
+		v215v1 = v
+		bs215 := testMarshalErr(v215v1, h, t, "enc-map-v215")
+		if v == nil {
+			v215v2 = nil
+		} else {
+			v215v2 = make(map[int8]bool, len(v))
+		} // reset map
+		testUnmarshalErr(v215v2, bs215, h, t, "dec-map-v215")
+		testDeepEqualErr(v215v1, v215v2, t, "equal-map-v215")
+		if v == nil {
+			v215v2 = nil
+		} else {
+			v215v2 = make(map[int8]bool, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v215v2), bs215, h, t, "dec-map-v215-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v215v1, v215v2, t, "equal-map-v215-noaddr")
+		if v == nil {
+			v215v2 = nil
+		} else {
+			v215v2 = make(map[int8]bool, len(v))
+		} // reset map
+		testUnmarshalErr(&v215v2, bs215, h, t, "dec-map-v215-p-len")
+		testDeepEqualErr(v215v1, v215v2, t, "equal-map-v215-p-len")
+		bs215 = testMarshalErr(&v215v1, h, t, "enc-map-v215-p")
+		v215v2 = nil
+		testUnmarshalErr(&v215v2, bs215, h, t, "dec-map-v215-p-nil")
+		testDeepEqualErr(v215v1, v215v2, t, "equal-map-v215-p-nil")
+		// ...
+		if v == nil {
+			v215v2 = nil
+		} else {
+			v215v2 = make(map[int8]bool, len(v))
+		} // reset map
+		var v215v3, v215v4 typMapMapInt8Bool
+		v215v3 = typMapMapInt8Bool(v215v1)
+		v215v4 = typMapMapInt8Bool(v215v2)
+		bs215 = testMarshalErr(v215v3, h, t, "enc-map-v215-custom")
+		testUnmarshalErr(v215v4, bs215, h, t, "dec-map-v215-p-len")
+		testDeepEqualErr(v215v3, v215v4, t, "equal-map-v215-p-len")
+	}
+
+	for _, v := range []map[int16]interface{}{nil, {}, {44: nil, 33: "string-is-an-interface-2"}} {
+		// fmt.Printf(">>>> running mammoth map v218: %v\n", v)
+		var v218v1, v218v2 map[int16]interface{}
+		v218v1 = v
+		bs218 := testMarshalErr(v218v1, h, t, "enc-map-v218")
+		if v == nil {
+			v218v2 = nil
+		} else {
+			v218v2 = make(map[int16]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(v218v2, bs218, h, t, "dec-map-v218")
+		testDeepEqualErr(v218v1, v218v2, t, "equal-map-v218")
+		if v == nil {
+			v218v2 = nil
+		} else {
+			v218v2 = make(map[int16]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v218v2), bs218, h, t, "dec-map-v218-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v218v1, v218v2, t, "equal-map-v218-noaddr")
+		if v == nil {
+			v218v2 = nil
+		} else {
+			v218v2 = make(map[int16]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(&v218v2, bs218, h, t, "dec-map-v218-p-len")
+		testDeepEqualErr(v218v1, v218v2, t, "equal-map-v218-p-len")
+		bs218 = testMarshalErr(&v218v1, h, t, "enc-map-v218-p")
+		v218v2 = nil
+		testUnmarshalErr(&v218v2, bs218, h, t, "dec-map-v218-p-nil")
+		testDeepEqualErr(v218v1, v218v2, t, "equal-map-v218-p-nil")
+		// ...
+		if v == nil {
+			v218v2 = nil
+		} else {
+			v218v2 = make(map[int16]interface{}, len(v))
+		} // reset map
+		var v218v3, v218v4 typMapMapInt16Intf
+		v218v3 = typMapMapInt16Intf(v218v1)
+		v218v4 = typMapMapInt16Intf(v218v2)
+		bs218 = testMarshalErr(v218v3, h, t, "enc-map-v218-custom")
+		testUnmarshalErr(v218v4, bs218, h, t, "dec-map-v218-p-len")
+		testDeepEqualErr(v218v3, v218v4, t, "equal-map-v218-p-len")
+	}
+
+	for _, v := range []map[int16]string{nil, {}, {44: "", 33: "some-string-2"}} {
+		// fmt.Printf(">>>> running mammoth map v219: %v\n", v)
+		var v219v1, v219v2 map[int16]string
+		v219v1 = v
+		bs219 := testMarshalErr(v219v1, h, t, "enc-map-v219")
+		if v == nil {
+			v219v2 = nil
+		} else {
+			v219v2 = make(map[int16]string, len(v))
+		} // reset map
+		testUnmarshalErr(v219v2, bs219, h, t, "dec-map-v219")
+		testDeepEqualErr(v219v1, v219v2, t, "equal-map-v219")
+		if v == nil {
+			v219v2 = nil
+		} else {
+			v219v2 = make(map[int16]string, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v219v2), bs219, h, t, "dec-map-v219-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v219v1, v219v2, t, "equal-map-v219-noaddr")
+		if v == nil {
+			v219v2 = nil
+		} else {
+			v219v2 = make(map[int16]string, len(v))
+		} // reset map
+		testUnmarshalErr(&v219v2, bs219, h, t, "dec-map-v219-p-len")
+		testDeepEqualErr(v219v1, v219v2, t, "equal-map-v219-p-len")
+		bs219 = testMarshalErr(&v219v1, h, t, "enc-map-v219-p")
+		v219v2 = nil
+		testUnmarshalErr(&v219v2, bs219, h, t, "dec-map-v219-p-nil")
+		testDeepEqualErr(v219v1, v219v2, t, "equal-map-v219-p-nil")
+		// ...
+		if v == nil {
+			v219v2 = nil
+		} else {
+			v219v2 = make(map[int16]string, len(v))
+		} // reset map
+		var v219v3, v219v4 typMapMapInt16String
+		v219v3 = typMapMapInt16String(v219v1)
+		v219v4 = typMapMapInt16String(v219v2)
+		bs219 = testMarshalErr(v219v3, h, t, "enc-map-v219-custom")
+		testUnmarshalErr(v219v4, bs219, h, t, "dec-map-v219-p-len")
+		testDeepEqualErr(v219v3, v219v4, t, "equal-map-v219-p-len")
+	}
+
+	for _, v := range []map[int16]uint{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v220: %v\n", v)
+		var v220v1, v220v2 map[int16]uint
+		v220v1 = v
+		bs220 := testMarshalErr(v220v1, h, t, "enc-map-v220")
+		if v == nil {
+			v220v2 = nil
+		} else {
+			v220v2 = make(map[int16]uint, len(v))
+		} // reset map
+		testUnmarshalErr(v220v2, bs220, h, t, "dec-map-v220")
+		testDeepEqualErr(v220v1, v220v2, t, "equal-map-v220")
+		if v == nil {
+			v220v2 = nil
+		} else {
+			v220v2 = make(map[int16]uint, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v220v2), bs220, h, t, "dec-map-v220-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v220v1, v220v2, t, "equal-map-v220-noaddr")
+		if v == nil {
+			v220v2 = nil
+		} else {
+			v220v2 = make(map[int16]uint, len(v))
+		} // reset map
+		testUnmarshalErr(&v220v2, bs220, h, t, "dec-map-v220-p-len")
+		testDeepEqualErr(v220v1, v220v2, t, "equal-map-v220-p-len")
+		bs220 = testMarshalErr(&v220v1, h, t, "enc-map-v220-p")
+		v220v2 = nil
+		testUnmarshalErr(&v220v2, bs220, h, t, "dec-map-v220-p-nil")
+		testDeepEqualErr(v220v1, v220v2, t, "equal-map-v220-p-nil")
+		// ...
+		if v == nil {
+			v220v2 = nil
+		} else {
+			v220v2 = make(map[int16]uint, len(v))
+		} // reset map
+		var v220v3, v220v4 typMapMapInt16Uint
+		v220v3 = typMapMapInt16Uint(v220v1)
+		v220v4 = typMapMapInt16Uint(v220v2)
+		bs220 = testMarshalErr(v220v3, h, t, "enc-map-v220-custom")
+		testUnmarshalErr(v220v4, bs220, h, t, "dec-map-v220-p-len")
+		testDeepEqualErr(v220v3, v220v4, t, "equal-map-v220-p-len")
+	}
+
+	for _, v := range []map[int16]uint8{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v221: %v\n", v)
+		var v221v1, v221v2 map[int16]uint8
+		v221v1 = v
+		bs221 := testMarshalErr(v221v1, h, t, "enc-map-v221")
+		if v == nil {
+			v221v2 = nil
+		} else {
+			v221v2 = make(map[int16]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(v221v2, bs221, h, t, "dec-map-v221")
+		testDeepEqualErr(v221v1, v221v2, t, "equal-map-v221")
+		if v == nil {
+			v221v2 = nil
+		} else {
+			v221v2 = make(map[int16]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v221v2), bs221, h, t, "dec-map-v221-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v221v1, v221v2, t, "equal-map-v221-noaddr")
+		if v == nil {
+			v221v2 = nil
+		} else {
+			v221v2 = make(map[int16]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(&v221v2, bs221, h, t, "dec-map-v221-p-len")
+		testDeepEqualErr(v221v1, v221v2, t, "equal-map-v221-p-len")
+		bs221 = testMarshalErr(&v221v1, h, t, "enc-map-v221-p")
+		v221v2 = nil
+		testUnmarshalErr(&v221v2, bs221, h, t, "dec-map-v221-p-nil")
+		testDeepEqualErr(v221v1, v221v2, t, "equal-map-v221-p-nil")
+		// ...
+		if v == nil {
+			v221v2 = nil
+		} else {
+			v221v2 = make(map[int16]uint8, len(v))
+		} // reset map
+		var v221v3, v221v4 typMapMapInt16Uint8
+		v221v3 = typMapMapInt16Uint8(v221v1)
+		v221v4 = typMapMapInt16Uint8(v221v2)
+		bs221 = testMarshalErr(v221v3, h, t, "enc-map-v221-custom")
+		testUnmarshalErr(v221v4, bs221, h, t, "dec-map-v221-p-len")
+		testDeepEqualErr(v221v3, v221v4, t, "equal-map-v221-p-len")
+	}
+
+	for _, v := range []map[int16]uint16{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v222: %v\n", v)
+		var v222v1, v222v2 map[int16]uint16
+		v222v1 = v
+		bs222 := testMarshalErr(v222v1, h, t, "enc-map-v222")
+		if v == nil {
+			v222v2 = nil
+		} else {
+			v222v2 = make(map[int16]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(v222v2, bs222, h, t, "dec-map-v222")
+		testDeepEqualErr(v222v1, v222v2, t, "equal-map-v222")
+		if v == nil {
+			v222v2 = nil
+		} else {
+			v222v2 = make(map[int16]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v222v2), bs222, h, t, "dec-map-v222-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v222v1, v222v2, t, "equal-map-v222-noaddr")
+		if v == nil {
+			v222v2 = nil
+		} else {
+			v222v2 = make(map[int16]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(&v222v2, bs222, h, t, "dec-map-v222-p-len")
+		testDeepEqualErr(v222v1, v222v2, t, "equal-map-v222-p-len")
+		bs222 = testMarshalErr(&v222v1, h, t, "enc-map-v222-p")
+		v222v2 = nil
+		testUnmarshalErr(&v222v2, bs222, h, t, "dec-map-v222-p-nil")
+		testDeepEqualErr(v222v1, v222v2, t, "equal-map-v222-p-nil")
+		// ...
+		if v == nil {
+			v222v2 = nil
+		} else {
+			v222v2 = make(map[int16]uint16, len(v))
+		} // reset map
+		var v222v3, v222v4 typMapMapInt16Uint16
+		v222v3 = typMapMapInt16Uint16(v222v1)
+		v222v4 = typMapMapInt16Uint16(v222v2)
+		bs222 = testMarshalErr(v222v3, h, t, "enc-map-v222-custom")
+		testUnmarshalErr(v222v4, bs222, h, t, "dec-map-v222-p-len")
+		testDeepEqualErr(v222v3, v222v4, t, "equal-map-v222-p-len")
+	}
+
+	for _, v := range []map[int16]uint32{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v223: %v\n", v)
+		var v223v1, v223v2 map[int16]uint32
+		v223v1 = v
+		bs223 := testMarshalErr(v223v1, h, t, "enc-map-v223")
+		if v == nil {
+			v223v2 = nil
+		} else {
+			v223v2 = make(map[int16]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(v223v2, bs223, h, t, "dec-map-v223")
+		testDeepEqualErr(v223v1, v223v2, t, "equal-map-v223")
+		if v == nil {
+			v223v2 = nil
+		} else {
+			v223v2 = make(map[int16]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v223v2), bs223, h, t, "dec-map-v223-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v223v1, v223v2, t, "equal-map-v223-noaddr")
+		if v == nil {
+			v223v2 = nil
+		} else {
+			v223v2 = make(map[int16]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(&v223v2, bs223, h, t, "dec-map-v223-p-len")
+		testDeepEqualErr(v223v1, v223v2, t, "equal-map-v223-p-len")
+		bs223 = testMarshalErr(&v223v1, h, t, "enc-map-v223-p")
+		v223v2 = nil
+		testUnmarshalErr(&v223v2, bs223, h, t, "dec-map-v223-p-nil")
+		testDeepEqualErr(v223v1, v223v2, t, "equal-map-v223-p-nil")
+		// ...
+		if v == nil {
+			v223v2 = nil
+		} else {
+			v223v2 = make(map[int16]uint32, len(v))
+		} // reset map
+		var v223v3, v223v4 typMapMapInt16Uint32
+		v223v3 = typMapMapInt16Uint32(v223v1)
+		v223v4 = typMapMapInt16Uint32(v223v2)
+		bs223 = testMarshalErr(v223v3, h, t, "enc-map-v223-custom")
+		testUnmarshalErr(v223v4, bs223, h, t, "dec-map-v223-p-len")
+		testDeepEqualErr(v223v3, v223v4, t, "equal-map-v223-p-len")
+	}
+
+	for _, v := range []map[int16]uint64{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v224: %v\n", v)
+		var v224v1, v224v2 map[int16]uint64
+		v224v1 = v
+		bs224 := testMarshalErr(v224v1, h, t, "enc-map-v224")
+		if v == nil {
+			v224v2 = nil
+		} else {
+			v224v2 = make(map[int16]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(v224v2, bs224, h, t, "dec-map-v224")
+		testDeepEqualErr(v224v1, v224v2, t, "equal-map-v224")
+		if v == nil {
+			v224v2 = nil
+		} else {
+			v224v2 = make(map[int16]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v224v2), bs224, h, t, "dec-map-v224-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v224v1, v224v2, t, "equal-map-v224-noaddr")
+		if v == nil {
+			v224v2 = nil
+		} else {
+			v224v2 = make(map[int16]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(&v224v2, bs224, h, t, "dec-map-v224-p-len")
+		testDeepEqualErr(v224v1, v224v2, t, "equal-map-v224-p-len")
+		bs224 = testMarshalErr(&v224v1, h, t, "enc-map-v224-p")
+		v224v2 = nil
+		testUnmarshalErr(&v224v2, bs224, h, t, "dec-map-v224-p-nil")
+		testDeepEqualErr(v224v1, v224v2, t, "equal-map-v224-p-nil")
+		// ...
+		if v == nil {
+			v224v2 = nil
+		} else {
+			v224v2 = make(map[int16]uint64, len(v))
+		} // reset map
+		var v224v3, v224v4 typMapMapInt16Uint64
+		v224v3 = typMapMapInt16Uint64(v224v1)
+		v224v4 = typMapMapInt16Uint64(v224v2)
+		bs224 = testMarshalErr(v224v3, h, t, "enc-map-v224-custom")
+		testUnmarshalErr(v224v4, bs224, h, t, "dec-map-v224-p-len")
+		testDeepEqualErr(v224v3, v224v4, t, "equal-map-v224-p-len")
+	}
+
+	for _, v := range []map[int16]uintptr{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v225: %v\n", v)
+		var v225v1, v225v2 map[int16]uintptr
+		v225v1 = v
+		bs225 := testMarshalErr(v225v1, h, t, "enc-map-v225")
+		if v == nil {
+			v225v2 = nil
+		} else {
+			v225v2 = make(map[int16]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(v225v2, bs225, h, t, "dec-map-v225")
+		testDeepEqualErr(v225v1, v225v2, t, "equal-map-v225")
+		if v == nil {
+			v225v2 = nil
+		} else {
+			v225v2 = make(map[int16]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v225v2), bs225, h, t, "dec-map-v225-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v225v1, v225v2, t, "equal-map-v225-noaddr")
+		if v == nil {
+			v225v2 = nil
+		} else {
+			v225v2 = make(map[int16]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(&v225v2, bs225, h, t, "dec-map-v225-p-len")
+		testDeepEqualErr(v225v1, v225v2, t, "equal-map-v225-p-len")
+		bs225 = testMarshalErr(&v225v1, h, t, "enc-map-v225-p")
+		v225v2 = nil
+		testUnmarshalErr(&v225v2, bs225, h, t, "dec-map-v225-p-nil")
+		testDeepEqualErr(v225v1, v225v2, t, "equal-map-v225-p-nil")
+		// ...
+		if v == nil {
+			v225v2 = nil
+		} else {
+			v225v2 = make(map[int16]uintptr, len(v))
+		} // reset map
+		var v225v3, v225v4 typMapMapInt16Uintptr
+		v225v3 = typMapMapInt16Uintptr(v225v1)
+		v225v4 = typMapMapInt16Uintptr(v225v2)
+		bs225 = testMarshalErr(v225v3, h, t, "enc-map-v225-custom")
+		testUnmarshalErr(v225v4, bs225, h, t, "dec-map-v225-p-len")
+		testDeepEqualErr(v225v3, v225v4, t, "equal-map-v225-p-len")
+	}
+
+	for _, v := range []map[int16]int{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v226: %v\n", v)
+		var v226v1, v226v2 map[int16]int
+		v226v1 = v
+		bs226 := testMarshalErr(v226v1, h, t, "enc-map-v226")
+		if v == nil {
+			v226v2 = nil
+		} else {
+			v226v2 = make(map[int16]int, len(v))
+		} // reset map
+		testUnmarshalErr(v226v2, bs226, h, t, "dec-map-v226")
+		testDeepEqualErr(v226v1, v226v2, t, "equal-map-v226")
+		if v == nil {
+			v226v2 = nil
+		} else {
+			v226v2 = make(map[int16]int, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v226v2), bs226, h, t, "dec-map-v226-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v226v1, v226v2, t, "equal-map-v226-noaddr")
+		if v == nil {
+			v226v2 = nil
+		} else {
+			v226v2 = make(map[int16]int, len(v))
+		} // reset map
+		testUnmarshalErr(&v226v2, bs226, h, t, "dec-map-v226-p-len")
+		testDeepEqualErr(v226v1, v226v2, t, "equal-map-v226-p-len")
+		bs226 = testMarshalErr(&v226v1, h, t, "enc-map-v226-p")
+		v226v2 = nil
+		testUnmarshalErr(&v226v2, bs226, h, t, "dec-map-v226-p-nil")
+		testDeepEqualErr(v226v1, v226v2, t, "equal-map-v226-p-nil")
+		// ...
+		if v == nil {
+			v226v2 = nil
+		} else {
+			v226v2 = make(map[int16]int, len(v))
+		} // reset map
+		var v226v3, v226v4 typMapMapInt16Int
+		v226v3 = typMapMapInt16Int(v226v1)
+		v226v4 = typMapMapInt16Int(v226v2)
+		bs226 = testMarshalErr(v226v3, h, t, "enc-map-v226-custom")
+		testUnmarshalErr(v226v4, bs226, h, t, "dec-map-v226-p-len")
+		testDeepEqualErr(v226v3, v226v4, t, "equal-map-v226-p-len")
+	}
+
+	for _, v := range []map[int16]int8{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v227: %v\n", v)
+		var v227v1, v227v2 map[int16]int8
+		v227v1 = v
+		bs227 := testMarshalErr(v227v1, h, t, "enc-map-v227")
+		if v == nil {
+			v227v2 = nil
+		} else {
+			v227v2 = make(map[int16]int8, len(v))
+		} // reset map
+		testUnmarshalErr(v227v2, bs227, h, t, "dec-map-v227")
+		testDeepEqualErr(v227v1, v227v2, t, "equal-map-v227")
+		if v == nil {
+			v227v2 = nil
+		} else {
+			v227v2 = make(map[int16]int8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v227v2), bs227, h, t, "dec-map-v227-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v227v1, v227v2, t, "equal-map-v227-noaddr")
+		if v == nil {
+			v227v2 = nil
+		} else {
+			v227v2 = make(map[int16]int8, len(v))
+		} // reset map
+		testUnmarshalErr(&v227v2, bs227, h, t, "dec-map-v227-p-len")
+		testDeepEqualErr(v227v1, v227v2, t, "equal-map-v227-p-len")
+		bs227 = testMarshalErr(&v227v1, h, t, "enc-map-v227-p")
+		v227v2 = nil
+		testUnmarshalErr(&v227v2, bs227, h, t, "dec-map-v227-p-nil")
+		testDeepEqualErr(v227v1, v227v2, t, "equal-map-v227-p-nil")
+		// ...
+		if v == nil {
+			v227v2 = nil
+		} else {
+			v227v2 = make(map[int16]int8, len(v))
+		} // reset map
+		var v227v3, v227v4 typMapMapInt16Int8
+		v227v3 = typMapMapInt16Int8(v227v1)
+		v227v4 = typMapMapInt16Int8(v227v2)
+		bs227 = testMarshalErr(v227v3, h, t, "enc-map-v227-custom")
+		testUnmarshalErr(v227v4, bs227, h, t, "dec-map-v227-p-len")
+		testDeepEqualErr(v227v3, v227v4, t, "equal-map-v227-p-len")
+	}
+
+	for _, v := range []map[int16]int16{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v228: %v\n", v)
+		var v228v1, v228v2 map[int16]int16
+		v228v1 = v
+		bs228 := testMarshalErr(v228v1, h, t, "enc-map-v228")
+		if v == nil {
+			v228v2 = nil
+		} else {
+			v228v2 = make(map[int16]int16, len(v))
+		} // reset map
+		testUnmarshalErr(v228v2, bs228, h, t, "dec-map-v228")
+		testDeepEqualErr(v228v1, v228v2, t, "equal-map-v228")
+		if v == nil {
+			v228v2 = nil
+		} else {
+			v228v2 = make(map[int16]int16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v228v2), bs228, h, t, "dec-map-v228-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v228v1, v228v2, t, "equal-map-v228-noaddr")
+		if v == nil {
+			v228v2 = nil
+		} else {
+			v228v2 = make(map[int16]int16, len(v))
+		} // reset map
+		testUnmarshalErr(&v228v2, bs228, h, t, "dec-map-v228-p-len")
+		testDeepEqualErr(v228v1, v228v2, t, "equal-map-v228-p-len")
+		bs228 = testMarshalErr(&v228v1, h, t, "enc-map-v228-p")
+		v228v2 = nil
+		testUnmarshalErr(&v228v2, bs228, h, t, "dec-map-v228-p-nil")
+		testDeepEqualErr(v228v1, v228v2, t, "equal-map-v228-p-nil")
+		// ...
+		if v == nil {
+			v228v2 = nil
+		} else {
+			v228v2 = make(map[int16]int16, len(v))
+		} // reset map
+		var v228v3, v228v4 typMapMapInt16Int16
+		v228v3 = typMapMapInt16Int16(v228v1)
+		v228v4 = typMapMapInt16Int16(v228v2)
+		bs228 = testMarshalErr(v228v3, h, t, "enc-map-v228-custom")
+		testUnmarshalErr(v228v4, bs228, h, t, "dec-map-v228-p-len")
+		testDeepEqualErr(v228v3, v228v4, t, "equal-map-v228-p-len")
+	}
+
+	for _, v := range []map[int16]int32{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v229: %v\n", v)
+		var v229v1, v229v2 map[int16]int32
+		v229v1 = v
+		bs229 := testMarshalErr(v229v1, h, t, "enc-map-v229")
+		if v == nil {
+			v229v2 = nil
+		} else {
+			v229v2 = make(map[int16]int32, len(v))
+		} // reset map
+		testUnmarshalErr(v229v2, bs229, h, t, "dec-map-v229")
+		testDeepEqualErr(v229v1, v229v2, t, "equal-map-v229")
+		if v == nil {
+			v229v2 = nil
+		} else {
+			v229v2 = make(map[int16]int32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v229v2), bs229, h, t, "dec-map-v229-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v229v1, v229v2, t, "equal-map-v229-noaddr")
+		if v == nil {
+			v229v2 = nil
+		} else {
+			v229v2 = make(map[int16]int32, len(v))
+		} // reset map
+		testUnmarshalErr(&v229v2, bs229, h, t, "dec-map-v229-p-len")
+		testDeepEqualErr(v229v1, v229v2, t, "equal-map-v229-p-len")
+		bs229 = testMarshalErr(&v229v1, h, t, "enc-map-v229-p")
+		v229v2 = nil
+		testUnmarshalErr(&v229v2, bs229, h, t, "dec-map-v229-p-nil")
+		testDeepEqualErr(v229v1, v229v2, t, "equal-map-v229-p-nil")
+		// ...
+		if v == nil {
+			v229v2 = nil
+		} else {
+			v229v2 = make(map[int16]int32, len(v))
+		} // reset map
+		var v229v3, v229v4 typMapMapInt16Int32
+		v229v3 = typMapMapInt16Int32(v229v1)
+		v229v4 = typMapMapInt16Int32(v229v2)
+		bs229 = testMarshalErr(v229v3, h, t, "enc-map-v229-custom")
+		testUnmarshalErr(v229v4, bs229, h, t, "dec-map-v229-p-len")
+		testDeepEqualErr(v229v3, v229v4, t, "equal-map-v229-p-len")
+	}
+
+	for _, v := range []map[int16]int64{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v230: %v\n", v)
+		var v230v1, v230v2 map[int16]int64
+		v230v1 = v
+		bs230 := testMarshalErr(v230v1, h, t, "enc-map-v230")
+		if v == nil {
+			v230v2 = nil
+		} else {
+			v230v2 = make(map[int16]int64, len(v))
+		} // reset map
+		testUnmarshalErr(v230v2, bs230, h, t, "dec-map-v230")
+		testDeepEqualErr(v230v1, v230v2, t, "equal-map-v230")
+		if v == nil {
+			v230v2 = nil
+		} else {
+			v230v2 = make(map[int16]int64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v230v2), bs230, h, t, "dec-map-v230-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v230v1, v230v2, t, "equal-map-v230-noaddr")
+		if v == nil {
+			v230v2 = nil
+		} else {
+			v230v2 = make(map[int16]int64, len(v))
+		} // reset map
+		testUnmarshalErr(&v230v2, bs230, h, t, "dec-map-v230-p-len")
+		testDeepEqualErr(v230v1, v230v2, t, "equal-map-v230-p-len")
+		bs230 = testMarshalErr(&v230v1, h, t, "enc-map-v230-p")
+		v230v2 = nil
+		testUnmarshalErr(&v230v2, bs230, h, t, "dec-map-v230-p-nil")
+		testDeepEqualErr(v230v1, v230v2, t, "equal-map-v230-p-nil")
+		// ...
+		if v == nil {
+			v230v2 = nil
+		} else {
+			v230v2 = make(map[int16]int64, len(v))
+		} // reset map
+		var v230v3, v230v4 typMapMapInt16Int64
+		v230v3 = typMapMapInt16Int64(v230v1)
+		v230v4 = typMapMapInt16Int64(v230v2)
+		bs230 = testMarshalErr(v230v3, h, t, "enc-map-v230-custom")
+		testUnmarshalErr(v230v4, bs230, h, t, "dec-map-v230-p-len")
+		testDeepEqualErr(v230v3, v230v4, t, "equal-map-v230-p-len")
+	}
+
+	for _, v := range []map[int16]float32{nil, {}, {33: 0, 44: 22.2}} {
+		// fmt.Printf(">>>> running mammoth map v231: %v\n", v)
+		var v231v1, v231v2 map[int16]float32
+		v231v1 = v
+		bs231 := testMarshalErr(v231v1, h, t, "enc-map-v231")
+		if v == nil {
+			v231v2 = nil
+		} else {
+			v231v2 = make(map[int16]float32, len(v))
+		} // reset map
+		testUnmarshalErr(v231v2, bs231, h, t, "dec-map-v231")
+		testDeepEqualErr(v231v1, v231v2, t, "equal-map-v231")
+		if v == nil {
+			v231v2 = nil
+		} else {
+			v231v2 = make(map[int16]float32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v231v2), bs231, h, t, "dec-map-v231-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v231v1, v231v2, t, "equal-map-v231-noaddr")
+		if v == nil {
+			v231v2 = nil
+		} else {
+			v231v2 = make(map[int16]float32, len(v))
+		} // reset map
+		testUnmarshalErr(&v231v2, bs231, h, t, "dec-map-v231-p-len")
+		testDeepEqualErr(v231v1, v231v2, t, "equal-map-v231-p-len")
+		bs231 = testMarshalErr(&v231v1, h, t, "enc-map-v231-p")
+		v231v2 = nil
+		testUnmarshalErr(&v231v2, bs231, h, t, "dec-map-v231-p-nil")
+		testDeepEqualErr(v231v1, v231v2, t, "equal-map-v231-p-nil")
+		// ...
+		if v == nil {
+			v231v2 = nil
+		} else {
+			v231v2 = make(map[int16]float32, len(v))
+		} // reset map
+		var v231v3, v231v4 typMapMapInt16Float32
+		v231v3 = typMapMapInt16Float32(v231v1)
+		v231v4 = typMapMapInt16Float32(v231v2)
+		bs231 = testMarshalErr(v231v3, h, t, "enc-map-v231-custom")
+		testUnmarshalErr(v231v4, bs231, h, t, "dec-map-v231-p-len")
+		testDeepEqualErr(v231v3, v231v4, t, "equal-map-v231-p-len")
+	}
+
+	for _, v := range []map[int16]float64{nil, {}, {33: 0, 44: 11.1}} {
+		// fmt.Printf(">>>> running mammoth map v232: %v\n", v)
+		var v232v1, v232v2 map[int16]float64
+		v232v1 = v
+		bs232 := testMarshalErr(v232v1, h, t, "enc-map-v232")
+		if v == nil {
+			v232v2 = nil
+		} else {
+			v232v2 = make(map[int16]float64, len(v))
+		} // reset map
+		testUnmarshalErr(v232v2, bs232, h, t, "dec-map-v232")
+		testDeepEqualErr(v232v1, v232v2, t, "equal-map-v232")
+		if v == nil {
+			v232v2 = nil
+		} else {
+			v232v2 = make(map[int16]float64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v232v2), bs232, h, t, "dec-map-v232-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v232v1, v232v2, t, "equal-map-v232-noaddr")
+		if v == nil {
+			v232v2 = nil
+		} else {
+			v232v2 = make(map[int16]float64, len(v))
+		} // reset map
+		testUnmarshalErr(&v232v2, bs232, h, t, "dec-map-v232-p-len")
+		testDeepEqualErr(v232v1, v232v2, t, "equal-map-v232-p-len")
+		bs232 = testMarshalErr(&v232v1, h, t, "enc-map-v232-p")
+		v232v2 = nil
+		testUnmarshalErr(&v232v2, bs232, h, t, "dec-map-v232-p-nil")
+		testDeepEqualErr(v232v1, v232v2, t, "equal-map-v232-p-nil")
+		// ...
+		if v == nil {
+			v232v2 = nil
+		} else {
+			v232v2 = make(map[int16]float64, len(v))
+		} // reset map
+		var v232v3, v232v4 typMapMapInt16Float64
+		v232v3 = typMapMapInt16Float64(v232v1)
+		v232v4 = typMapMapInt16Float64(v232v2)
+		bs232 = testMarshalErr(v232v3, h, t, "enc-map-v232-custom")
+		testUnmarshalErr(v232v4, bs232, h, t, "dec-map-v232-p-len")
+		testDeepEqualErr(v232v3, v232v4, t, "equal-map-v232-p-len")
+	}
+
+	for _, v := range []map[int16]bool{nil, {}, {33: false, 44: true}} {
+		// fmt.Printf(">>>> running mammoth map v233: %v\n", v)
+		var v233v1, v233v2 map[int16]bool
+		v233v1 = v
+		bs233 := testMarshalErr(v233v1, h, t, "enc-map-v233")
+		if v == nil {
+			v233v2 = nil
+		} else {
+			v233v2 = make(map[int16]bool, len(v))
+		} // reset map
+		testUnmarshalErr(v233v2, bs233, h, t, "dec-map-v233")
+		testDeepEqualErr(v233v1, v233v2, t, "equal-map-v233")
+		if v == nil {
+			v233v2 = nil
+		} else {
+			v233v2 = make(map[int16]bool, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v233v2), bs233, h, t, "dec-map-v233-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v233v1, v233v2, t, "equal-map-v233-noaddr")
+		if v == nil {
+			v233v2 = nil
+		} else {
+			v233v2 = make(map[int16]bool, len(v))
+		} // reset map
+		testUnmarshalErr(&v233v2, bs233, h, t, "dec-map-v233-p-len")
+		testDeepEqualErr(v233v1, v233v2, t, "equal-map-v233-p-len")
+		bs233 = testMarshalErr(&v233v1, h, t, "enc-map-v233-p")
+		v233v2 = nil
+		testUnmarshalErr(&v233v2, bs233, h, t, "dec-map-v233-p-nil")
+		testDeepEqualErr(v233v1, v233v2, t, "equal-map-v233-p-nil")
+		// ...
+		if v == nil {
+			v233v2 = nil
+		} else {
+			v233v2 = make(map[int16]bool, len(v))
+		} // reset map
+		var v233v3, v233v4 typMapMapInt16Bool
+		v233v3 = typMapMapInt16Bool(v233v1)
+		v233v4 = typMapMapInt16Bool(v233v2)
+		bs233 = testMarshalErr(v233v3, h, t, "enc-map-v233-custom")
+		testUnmarshalErr(v233v4, bs233, h, t, "dec-map-v233-p-len")
+		testDeepEqualErr(v233v3, v233v4, t, "equal-map-v233-p-len")
+	}
+
+	for _, v := range []map[int32]interface{}{nil, {}, {33: nil, 44: "string-is-an-interface"}} {
+		// fmt.Printf(">>>> running mammoth map v236: %v\n", v)
+		var v236v1, v236v2 map[int32]interface{}
+		v236v1 = v
+		bs236 := testMarshalErr(v236v1, h, t, "enc-map-v236")
+		if v == nil {
+			v236v2 = nil
+		} else {
+			v236v2 = make(map[int32]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(v236v2, bs236, h, t, "dec-map-v236")
+		testDeepEqualErr(v236v1, v236v2, t, "equal-map-v236")
+		if v == nil {
+			v236v2 = nil
+		} else {
+			v236v2 = make(map[int32]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v236v2), bs236, h, t, "dec-map-v236-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v236v1, v236v2, t, "equal-map-v236-noaddr")
+		if v == nil {
+			v236v2 = nil
+		} else {
+			v236v2 = make(map[int32]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(&v236v2, bs236, h, t, "dec-map-v236-p-len")
+		testDeepEqualErr(v236v1, v236v2, t, "equal-map-v236-p-len")
+		bs236 = testMarshalErr(&v236v1, h, t, "enc-map-v236-p")
+		v236v2 = nil
+		testUnmarshalErr(&v236v2, bs236, h, t, "dec-map-v236-p-nil")
+		testDeepEqualErr(v236v1, v236v2, t, "equal-map-v236-p-nil")
+		// ...
+		if v == nil {
+			v236v2 = nil
+		} else {
+			v236v2 = make(map[int32]interface{}, len(v))
+		} // reset map
+		var v236v3, v236v4 typMapMapInt32Intf
+		v236v3 = typMapMapInt32Intf(v236v1)
+		v236v4 = typMapMapInt32Intf(v236v2)
+		bs236 = testMarshalErr(v236v3, h, t, "enc-map-v236-custom")
+		testUnmarshalErr(v236v4, bs236, h, t, "dec-map-v236-p-len")
+		testDeepEqualErr(v236v3, v236v4, t, "equal-map-v236-p-len")
+	}
+
+	for _, v := range []map[int32]string{nil, {}, {33: "", 44: "some-string"}} {
+		// fmt.Printf(">>>> running mammoth map v237: %v\n", v)
+		var v237v1, v237v2 map[int32]string
+		v237v1 = v
+		bs237 := testMarshalErr(v237v1, h, t, "enc-map-v237")
+		if v == nil {
+			v237v2 = nil
+		} else {
+			v237v2 = make(map[int32]string, len(v))
+		} // reset map
+		testUnmarshalErr(v237v2, bs237, h, t, "dec-map-v237")
+		testDeepEqualErr(v237v1, v237v2, t, "equal-map-v237")
+		if v == nil {
+			v237v2 = nil
+		} else {
+			v237v2 = make(map[int32]string, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v237v2), bs237, h, t, "dec-map-v237-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v237v1, v237v2, t, "equal-map-v237-noaddr")
+		if v == nil {
+			v237v2 = nil
+		} else {
+			v237v2 = make(map[int32]string, len(v))
+		} // reset map
+		testUnmarshalErr(&v237v2, bs237, h, t, "dec-map-v237-p-len")
+		testDeepEqualErr(v237v1, v237v2, t, "equal-map-v237-p-len")
+		bs237 = testMarshalErr(&v237v1, h, t, "enc-map-v237-p")
+		v237v2 = nil
+		testUnmarshalErr(&v237v2, bs237, h, t, "dec-map-v237-p-nil")
+		testDeepEqualErr(v237v1, v237v2, t, "equal-map-v237-p-nil")
+		// ...
+		if v == nil {
+			v237v2 = nil
+		} else {
+			v237v2 = make(map[int32]string, len(v))
+		} // reset map
+		var v237v3, v237v4 typMapMapInt32String
+		v237v3 = typMapMapInt32String(v237v1)
+		v237v4 = typMapMapInt32String(v237v2)
+		bs237 = testMarshalErr(v237v3, h, t, "enc-map-v237-custom")
+		testUnmarshalErr(v237v4, bs237, h, t, "dec-map-v237-p-len")
+		testDeepEqualErr(v237v3, v237v4, t, "equal-map-v237-p-len")
+	}
+
+	for _, v := range []map[int32]uint{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v238: %v\n", v)
+		var v238v1, v238v2 map[int32]uint
+		v238v1 = v
+		bs238 := testMarshalErr(v238v1, h, t, "enc-map-v238")
+		if v == nil {
+			v238v2 = nil
+		} else {
+			v238v2 = make(map[int32]uint, len(v))
+		} // reset map
+		testUnmarshalErr(v238v2, bs238, h, t, "dec-map-v238")
+		testDeepEqualErr(v238v1, v238v2, t, "equal-map-v238")
+		if v == nil {
+			v238v2 = nil
+		} else {
+			v238v2 = make(map[int32]uint, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v238v2), bs238, h, t, "dec-map-v238-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v238v1, v238v2, t, "equal-map-v238-noaddr")
+		if v == nil {
+			v238v2 = nil
+		} else {
+			v238v2 = make(map[int32]uint, len(v))
+		} // reset map
+		testUnmarshalErr(&v238v2, bs238, h, t, "dec-map-v238-p-len")
+		testDeepEqualErr(v238v1, v238v2, t, "equal-map-v238-p-len")
+		bs238 = testMarshalErr(&v238v1, h, t, "enc-map-v238-p")
+		v238v2 = nil
+		testUnmarshalErr(&v238v2, bs238, h, t, "dec-map-v238-p-nil")
+		testDeepEqualErr(v238v1, v238v2, t, "equal-map-v238-p-nil")
+		// ...
+		if v == nil {
+			v238v2 = nil
+		} else {
+			v238v2 = make(map[int32]uint, len(v))
+		} // reset map
+		var v238v3, v238v4 typMapMapInt32Uint
+		v238v3 = typMapMapInt32Uint(v238v1)
+		v238v4 = typMapMapInt32Uint(v238v2)
+		bs238 = testMarshalErr(v238v3, h, t, "enc-map-v238-custom")
+		testUnmarshalErr(v238v4, bs238, h, t, "dec-map-v238-p-len")
+		testDeepEqualErr(v238v3, v238v4, t, "equal-map-v238-p-len")
+	}
+
+	for _, v := range []map[int32]uint8{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v239: %v\n", v)
+		var v239v1, v239v2 map[int32]uint8
+		v239v1 = v
+		bs239 := testMarshalErr(v239v1, h, t, "enc-map-v239")
+		if v == nil {
+			v239v2 = nil
+		} else {
+			v239v2 = make(map[int32]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(v239v2, bs239, h, t, "dec-map-v239")
+		testDeepEqualErr(v239v1, v239v2, t, "equal-map-v239")
+		if v == nil {
+			v239v2 = nil
+		} else {
+			v239v2 = make(map[int32]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v239v2), bs239, h, t, "dec-map-v239-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v239v1, v239v2, t, "equal-map-v239-noaddr")
+		if v == nil {
+			v239v2 = nil
+		} else {
+			v239v2 = make(map[int32]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(&v239v2, bs239, h, t, "dec-map-v239-p-len")
+		testDeepEqualErr(v239v1, v239v2, t, "equal-map-v239-p-len")
+		bs239 = testMarshalErr(&v239v1, h, t, "enc-map-v239-p")
+		v239v2 = nil
+		testUnmarshalErr(&v239v2, bs239, h, t, "dec-map-v239-p-nil")
+		testDeepEqualErr(v239v1, v239v2, t, "equal-map-v239-p-nil")
+		// ...
+		if v == nil {
+			v239v2 = nil
+		} else {
+			v239v2 = make(map[int32]uint8, len(v))
+		} // reset map
+		var v239v3, v239v4 typMapMapInt32Uint8
+		v239v3 = typMapMapInt32Uint8(v239v1)
+		v239v4 = typMapMapInt32Uint8(v239v2)
+		bs239 = testMarshalErr(v239v3, h, t, "enc-map-v239-custom")
+		testUnmarshalErr(v239v4, bs239, h, t, "dec-map-v239-p-len")
+		testDeepEqualErr(v239v3, v239v4, t, "equal-map-v239-p-len")
+	}
+
+	for _, v := range []map[int32]uint16{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v240: %v\n", v)
+		var v240v1, v240v2 map[int32]uint16
+		v240v1 = v
+		bs240 := testMarshalErr(v240v1, h, t, "enc-map-v240")
+		if v == nil {
+			v240v2 = nil
+		} else {
+			v240v2 = make(map[int32]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(v240v2, bs240, h, t, "dec-map-v240")
+		testDeepEqualErr(v240v1, v240v2, t, "equal-map-v240")
+		if v == nil {
+			v240v2 = nil
+		} else {
+			v240v2 = make(map[int32]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v240v2), bs240, h, t, "dec-map-v240-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v240v1, v240v2, t, "equal-map-v240-noaddr")
+		if v == nil {
+			v240v2 = nil
+		} else {
+			v240v2 = make(map[int32]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(&v240v2, bs240, h, t, "dec-map-v240-p-len")
+		testDeepEqualErr(v240v1, v240v2, t, "equal-map-v240-p-len")
+		bs240 = testMarshalErr(&v240v1, h, t, "enc-map-v240-p")
+		v240v2 = nil
+		testUnmarshalErr(&v240v2, bs240, h, t, "dec-map-v240-p-nil")
+		testDeepEqualErr(v240v1, v240v2, t, "equal-map-v240-p-nil")
+		// ...
+		if v == nil {
+			v240v2 = nil
+		} else {
+			v240v2 = make(map[int32]uint16, len(v))
+		} // reset map
+		var v240v3, v240v4 typMapMapInt32Uint16
+		v240v3 = typMapMapInt32Uint16(v240v1)
+		v240v4 = typMapMapInt32Uint16(v240v2)
+		bs240 = testMarshalErr(v240v3, h, t, "enc-map-v240-custom")
+		testUnmarshalErr(v240v4, bs240, h, t, "dec-map-v240-p-len")
+		testDeepEqualErr(v240v3, v240v4, t, "equal-map-v240-p-len")
+	}
+
+	for _, v := range []map[int32]uint32{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v241: %v\n", v)
+		var v241v1, v241v2 map[int32]uint32
+		v241v1 = v
+		bs241 := testMarshalErr(v241v1, h, t, "enc-map-v241")
+		if v == nil {
+			v241v2 = nil
+		} else {
+			v241v2 = make(map[int32]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(v241v2, bs241, h, t, "dec-map-v241")
+		testDeepEqualErr(v241v1, v241v2, t, "equal-map-v241")
+		if v == nil {
+			v241v2 = nil
+		} else {
+			v241v2 = make(map[int32]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v241v2), bs241, h, t, "dec-map-v241-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v241v1, v241v2, t, "equal-map-v241-noaddr")
+		if v == nil {
+			v241v2 = nil
+		} else {
+			v241v2 = make(map[int32]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(&v241v2, bs241, h, t, "dec-map-v241-p-len")
+		testDeepEqualErr(v241v1, v241v2, t, "equal-map-v241-p-len")
+		bs241 = testMarshalErr(&v241v1, h, t, "enc-map-v241-p")
+		v241v2 = nil
+		testUnmarshalErr(&v241v2, bs241, h, t, "dec-map-v241-p-nil")
+		testDeepEqualErr(v241v1, v241v2, t, "equal-map-v241-p-nil")
+		// ...
+		if v == nil {
+			v241v2 = nil
+		} else {
+			v241v2 = make(map[int32]uint32, len(v))
+		} // reset map
+		var v241v3, v241v4 typMapMapInt32Uint32
+		v241v3 = typMapMapInt32Uint32(v241v1)
+		v241v4 = typMapMapInt32Uint32(v241v2)
+		bs241 = testMarshalErr(v241v3, h, t, "enc-map-v241-custom")
+		testUnmarshalErr(v241v4, bs241, h, t, "dec-map-v241-p-len")
+		testDeepEqualErr(v241v3, v241v4, t, "equal-map-v241-p-len")
+	}
+
+	for _, v := range []map[int32]uint64{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v242: %v\n", v)
+		var v242v1, v242v2 map[int32]uint64
+		v242v1 = v
+		bs242 := testMarshalErr(v242v1, h, t, "enc-map-v242")
+		if v == nil {
+			v242v2 = nil
+		} else {
+			v242v2 = make(map[int32]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(v242v2, bs242, h, t, "dec-map-v242")
+		testDeepEqualErr(v242v1, v242v2, t, "equal-map-v242")
+		if v == nil {
+			v242v2 = nil
+		} else {
+			v242v2 = make(map[int32]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v242v2), bs242, h, t, "dec-map-v242-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v242v1, v242v2, t, "equal-map-v242-noaddr")
+		if v == nil {
+			v242v2 = nil
+		} else {
+			v242v2 = make(map[int32]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(&v242v2, bs242, h, t, "dec-map-v242-p-len")
+		testDeepEqualErr(v242v1, v242v2, t, "equal-map-v242-p-len")
+		bs242 = testMarshalErr(&v242v1, h, t, "enc-map-v242-p")
+		v242v2 = nil
+		testUnmarshalErr(&v242v2, bs242, h, t, "dec-map-v242-p-nil")
+		testDeepEqualErr(v242v1, v242v2, t, "equal-map-v242-p-nil")
+		// ...
+		if v == nil {
+			v242v2 = nil
+		} else {
+			v242v2 = make(map[int32]uint64, len(v))
+		} // reset map
+		var v242v3, v242v4 typMapMapInt32Uint64
+		v242v3 = typMapMapInt32Uint64(v242v1)
+		v242v4 = typMapMapInt32Uint64(v242v2)
+		bs242 = testMarshalErr(v242v3, h, t, "enc-map-v242-custom")
+		testUnmarshalErr(v242v4, bs242, h, t, "dec-map-v242-p-len")
+		testDeepEqualErr(v242v3, v242v4, t, "equal-map-v242-p-len")
+	}
+
+	for _, v := range []map[int32]uintptr{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v243: %v\n", v)
+		var v243v1, v243v2 map[int32]uintptr
+		v243v1 = v
+		bs243 := testMarshalErr(v243v1, h, t, "enc-map-v243")
+		if v == nil {
+			v243v2 = nil
+		} else {
+			v243v2 = make(map[int32]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(v243v2, bs243, h, t, "dec-map-v243")
+		testDeepEqualErr(v243v1, v243v2, t, "equal-map-v243")
+		if v == nil {
+			v243v2 = nil
+		} else {
+			v243v2 = make(map[int32]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v243v2), bs243, h, t, "dec-map-v243-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v243v1, v243v2, t, "equal-map-v243-noaddr")
+		if v == nil {
+			v243v2 = nil
+		} else {
+			v243v2 = make(map[int32]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(&v243v2, bs243, h, t, "dec-map-v243-p-len")
+		testDeepEqualErr(v243v1, v243v2, t, "equal-map-v243-p-len")
+		bs243 = testMarshalErr(&v243v1, h, t, "enc-map-v243-p")
+		v243v2 = nil
+		testUnmarshalErr(&v243v2, bs243, h, t, "dec-map-v243-p-nil")
+		testDeepEqualErr(v243v1, v243v2, t, "equal-map-v243-p-nil")
+		// ...
+		if v == nil {
+			v243v2 = nil
+		} else {
+			v243v2 = make(map[int32]uintptr, len(v))
+		} // reset map
+		var v243v3, v243v4 typMapMapInt32Uintptr
+		v243v3 = typMapMapInt32Uintptr(v243v1)
+		v243v4 = typMapMapInt32Uintptr(v243v2)
+		bs243 = testMarshalErr(v243v3, h, t, "enc-map-v243-custom")
+		testUnmarshalErr(v243v4, bs243, h, t, "dec-map-v243-p-len")
+		testDeepEqualErr(v243v3, v243v4, t, "equal-map-v243-p-len")
+	}
+
+	for _, v := range []map[int32]int{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v244: %v\n", v)
+		var v244v1, v244v2 map[int32]int
+		v244v1 = v
+		bs244 := testMarshalErr(v244v1, h, t, "enc-map-v244")
+		if v == nil {
+			v244v2 = nil
+		} else {
+			v244v2 = make(map[int32]int, len(v))
+		} // reset map
+		testUnmarshalErr(v244v2, bs244, h, t, "dec-map-v244")
+		testDeepEqualErr(v244v1, v244v2, t, "equal-map-v244")
+		if v == nil {
+			v244v2 = nil
+		} else {
+			v244v2 = make(map[int32]int, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v244v2), bs244, h, t, "dec-map-v244-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v244v1, v244v2, t, "equal-map-v244-noaddr")
+		if v == nil {
+			v244v2 = nil
+		} else {
+			v244v2 = make(map[int32]int, len(v))
+		} // reset map
+		testUnmarshalErr(&v244v2, bs244, h, t, "dec-map-v244-p-len")
+		testDeepEqualErr(v244v1, v244v2, t, "equal-map-v244-p-len")
+		bs244 = testMarshalErr(&v244v1, h, t, "enc-map-v244-p")
+		v244v2 = nil
+		testUnmarshalErr(&v244v2, bs244, h, t, "dec-map-v244-p-nil")
+		testDeepEqualErr(v244v1, v244v2, t, "equal-map-v244-p-nil")
+		// ...
+		if v == nil {
+			v244v2 = nil
+		} else {
+			v244v2 = make(map[int32]int, len(v))
+		} // reset map
+		var v244v3, v244v4 typMapMapInt32Int
+		v244v3 = typMapMapInt32Int(v244v1)
+		v244v4 = typMapMapInt32Int(v244v2)
+		bs244 = testMarshalErr(v244v3, h, t, "enc-map-v244-custom")
+		testUnmarshalErr(v244v4, bs244, h, t, "dec-map-v244-p-len")
+		testDeepEqualErr(v244v3, v244v4, t, "equal-map-v244-p-len")
+	}
+
+	for _, v := range []map[int32]int8{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v245: %v\n", v)
+		var v245v1, v245v2 map[int32]int8
+		v245v1 = v
+		bs245 := testMarshalErr(v245v1, h, t, "enc-map-v245")
+		if v == nil {
+			v245v2 = nil
+		} else {
+			v245v2 = make(map[int32]int8, len(v))
+		} // reset map
+		testUnmarshalErr(v245v2, bs245, h, t, "dec-map-v245")
+		testDeepEqualErr(v245v1, v245v2, t, "equal-map-v245")
+		if v == nil {
+			v245v2 = nil
+		} else {
+			v245v2 = make(map[int32]int8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v245v2), bs245, h, t, "dec-map-v245-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v245v1, v245v2, t, "equal-map-v245-noaddr")
+		if v == nil {
+			v245v2 = nil
+		} else {
+			v245v2 = make(map[int32]int8, len(v))
+		} // reset map
+		testUnmarshalErr(&v245v2, bs245, h, t, "dec-map-v245-p-len")
+		testDeepEqualErr(v245v1, v245v2, t, "equal-map-v245-p-len")
+		bs245 = testMarshalErr(&v245v1, h, t, "enc-map-v245-p")
+		v245v2 = nil
+		testUnmarshalErr(&v245v2, bs245, h, t, "dec-map-v245-p-nil")
+		testDeepEqualErr(v245v1, v245v2, t, "equal-map-v245-p-nil")
+		// ...
+		if v == nil {
+			v245v2 = nil
+		} else {
+			v245v2 = make(map[int32]int8, len(v))
+		} // reset map
+		var v245v3, v245v4 typMapMapInt32Int8
+		v245v3 = typMapMapInt32Int8(v245v1)
+		v245v4 = typMapMapInt32Int8(v245v2)
+		bs245 = testMarshalErr(v245v3, h, t, "enc-map-v245-custom")
+		testUnmarshalErr(v245v4, bs245, h, t, "dec-map-v245-p-len")
+		testDeepEqualErr(v245v3, v245v4, t, "equal-map-v245-p-len")
+	}
+
+	for _, v := range []map[int32]int16{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v246: %v\n", v)
+		var v246v1, v246v2 map[int32]int16
+		v246v1 = v
+		bs246 := testMarshalErr(v246v1, h, t, "enc-map-v246")
+		if v == nil {
+			v246v2 = nil
+		} else {
+			v246v2 = make(map[int32]int16, len(v))
+		} // reset map
+		testUnmarshalErr(v246v2, bs246, h, t, "dec-map-v246")
+		testDeepEqualErr(v246v1, v246v2, t, "equal-map-v246")
+		if v == nil {
+			v246v2 = nil
+		} else {
+			v246v2 = make(map[int32]int16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v246v2), bs246, h, t, "dec-map-v246-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v246v1, v246v2, t, "equal-map-v246-noaddr")
+		if v == nil {
+			v246v2 = nil
+		} else {
+			v246v2 = make(map[int32]int16, len(v))
+		} // reset map
+		testUnmarshalErr(&v246v2, bs246, h, t, "dec-map-v246-p-len")
+		testDeepEqualErr(v246v1, v246v2, t, "equal-map-v246-p-len")
+		bs246 = testMarshalErr(&v246v1, h, t, "enc-map-v246-p")
+		v246v2 = nil
+		testUnmarshalErr(&v246v2, bs246, h, t, "dec-map-v246-p-nil")
+		testDeepEqualErr(v246v1, v246v2, t, "equal-map-v246-p-nil")
+		// ...
+		if v == nil {
+			v246v2 = nil
+		} else {
+			v246v2 = make(map[int32]int16, len(v))
+		} // reset map
+		var v246v3, v246v4 typMapMapInt32Int16
+		v246v3 = typMapMapInt32Int16(v246v1)
+		v246v4 = typMapMapInt32Int16(v246v2)
+		bs246 = testMarshalErr(v246v3, h, t, "enc-map-v246-custom")
+		testUnmarshalErr(v246v4, bs246, h, t, "dec-map-v246-p-len")
+		testDeepEqualErr(v246v3, v246v4, t, "equal-map-v246-p-len")
+	}
+
+	for _, v := range []map[int32]int32{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v247: %v\n", v)
+		var v247v1, v247v2 map[int32]int32
+		v247v1 = v
+		bs247 := testMarshalErr(v247v1, h, t, "enc-map-v247")
+		if v == nil {
+			v247v2 = nil
+		} else {
+			v247v2 = make(map[int32]int32, len(v))
+		} // reset map
+		testUnmarshalErr(v247v2, bs247, h, t, "dec-map-v247")
+		testDeepEqualErr(v247v1, v247v2, t, "equal-map-v247")
+		if v == nil {
+			v247v2 = nil
+		} else {
+			v247v2 = make(map[int32]int32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v247v2), bs247, h, t, "dec-map-v247-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v247v1, v247v2, t, "equal-map-v247-noaddr")
+		if v == nil {
+			v247v2 = nil
+		} else {
+			v247v2 = make(map[int32]int32, len(v))
+		} // reset map
+		testUnmarshalErr(&v247v2, bs247, h, t, "dec-map-v247-p-len")
+		testDeepEqualErr(v247v1, v247v2, t, "equal-map-v247-p-len")
+		bs247 = testMarshalErr(&v247v1, h, t, "enc-map-v247-p")
+		v247v2 = nil
+		testUnmarshalErr(&v247v2, bs247, h, t, "dec-map-v247-p-nil")
+		testDeepEqualErr(v247v1, v247v2, t, "equal-map-v247-p-nil")
+		// ...
+		if v == nil {
+			v247v2 = nil
+		} else {
+			v247v2 = make(map[int32]int32, len(v))
+		} // reset map
+		var v247v3, v247v4 typMapMapInt32Int32
+		v247v3 = typMapMapInt32Int32(v247v1)
+		v247v4 = typMapMapInt32Int32(v247v2)
+		bs247 = testMarshalErr(v247v3, h, t, "enc-map-v247-custom")
+		testUnmarshalErr(v247v4, bs247, h, t, "dec-map-v247-p-len")
+		testDeepEqualErr(v247v3, v247v4, t, "equal-map-v247-p-len")
+	}
+
+	for _, v := range []map[int32]int64{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v248: %v\n", v)
+		var v248v1, v248v2 map[int32]int64
+		v248v1 = v
+		bs248 := testMarshalErr(v248v1, h, t, "enc-map-v248")
+		if v == nil {
+			v248v2 = nil
+		} else {
+			v248v2 = make(map[int32]int64, len(v))
+		} // reset map
+		testUnmarshalErr(v248v2, bs248, h, t, "dec-map-v248")
+		testDeepEqualErr(v248v1, v248v2, t, "equal-map-v248")
+		if v == nil {
+			v248v2 = nil
+		} else {
+			v248v2 = make(map[int32]int64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v248v2), bs248, h, t, "dec-map-v248-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v248v1, v248v2, t, "equal-map-v248-noaddr")
+		if v == nil {
+			v248v2 = nil
+		} else {
+			v248v2 = make(map[int32]int64, len(v))
+		} // reset map
+		testUnmarshalErr(&v248v2, bs248, h, t, "dec-map-v248-p-len")
+		testDeepEqualErr(v248v1, v248v2, t, "equal-map-v248-p-len")
+		bs248 = testMarshalErr(&v248v1, h, t, "enc-map-v248-p")
+		v248v2 = nil
+		testUnmarshalErr(&v248v2, bs248, h, t, "dec-map-v248-p-nil")
+		testDeepEqualErr(v248v1, v248v2, t, "equal-map-v248-p-nil")
+		// ...
+		if v == nil {
+			v248v2 = nil
+		} else {
+			v248v2 = make(map[int32]int64, len(v))
+		} // reset map
+		var v248v3, v248v4 typMapMapInt32Int64
+		v248v3 = typMapMapInt32Int64(v248v1)
+		v248v4 = typMapMapInt32Int64(v248v2)
+		bs248 = testMarshalErr(v248v3, h, t, "enc-map-v248-custom")
+		testUnmarshalErr(v248v4, bs248, h, t, "dec-map-v248-p-len")
+		testDeepEqualErr(v248v3, v248v4, t, "equal-map-v248-p-len")
+	}
+
+	for _, v := range []map[int32]float32{nil, {}, {44: 0, 33: 22.2}} {
+		// fmt.Printf(">>>> running mammoth map v249: %v\n", v)
+		var v249v1, v249v2 map[int32]float32
+		v249v1 = v
+		bs249 := testMarshalErr(v249v1, h, t, "enc-map-v249")
+		if v == nil {
+			v249v2 = nil
+		} else {
+			v249v2 = make(map[int32]float32, len(v))
+		} // reset map
+		testUnmarshalErr(v249v2, bs249, h, t, "dec-map-v249")
+		testDeepEqualErr(v249v1, v249v2, t, "equal-map-v249")
+		if v == nil {
+			v249v2 = nil
+		} else {
+			v249v2 = make(map[int32]float32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v249v2), bs249, h, t, "dec-map-v249-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v249v1, v249v2, t, "equal-map-v249-noaddr")
+		if v == nil {
+			v249v2 = nil
+		} else {
+			v249v2 = make(map[int32]float32, len(v))
+		} // reset map
+		testUnmarshalErr(&v249v2, bs249, h, t, "dec-map-v249-p-len")
+		testDeepEqualErr(v249v1, v249v2, t, "equal-map-v249-p-len")
+		bs249 = testMarshalErr(&v249v1, h, t, "enc-map-v249-p")
+		v249v2 = nil
+		testUnmarshalErr(&v249v2, bs249, h, t, "dec-map-v249-p-nil")
+		testDeepEqualErr(v249v1, v249v2, t, "equal-map-v249-p-nil")
+		// ...
+		if v == nil {
+			v249v2 = nil
+		} else {
+			v249v2 = make(map[int32]float32, len(v))
+		} // reset map
+		var v249v3, v249v4 typMapMapInt32Float32
+		v249v3 = typMapMapInt32Float32(v249v1)
+		v249v4 = typMapMapInt32Float32(v249v2)
+		bs249 = testMarshalErr(v249v3, h, t, "enc-map-v249-custom")
+		testUnmarshalErr(v249v4, bs249, h, t, "dec-map-v249-p-len")
+		testDeepEqualErr(v249v3, v249v4, t, "equal-map-v249-p-len")
+	}
+
+	for _, v := range []map[int32]float64{nil, {}, {44: 0, 33: 11.1}} {
+		// fmt.Printf(">>>> running mammoth map v250: %v\n", v)
+		var v250v1, v250v2 map[int32]float64
+		v250v1 = v
+		bs250 := testMarshalErr(v250v1, h, t, "enc-map-v250")
+		if v == nil {
+			v250v2 = nil
+		} else {
+			v250v2 = make(map[int32]float64, len(v))
+		} // reset map
+		testUnmarshalErr(v250v2, bs250, h, t, "dec-map-v250")
+		testDeepEqualErr(v250v1, v250v2, t, "equal-map-v250")
+		if v == nil {
+			v250v2 = nil
+		} else {
+			v250v2 = make(map[int32]float64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v250v2), bs250, h, t, "dec-map-v250-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v250v1, v250v2, t, "equal-map-v250-noaddr")
+		if v == nil {
+			v250v2 = nil
+		} else {
+			v250v2 = make(map[int32]float64, len(v))
+		} // reset map
+		testUnmarshalErr(&v250v2, bs250, h, t, "dec-map-v250-p-len")
+		testDeepEqualErr(v250v1, v250v2, t, "equal-map-v250-p-len")
+		bs250 = testMarshalErr(&v250v1, h, t, "enc-map-v250-p")
+		v250v2 = nil
+		testUnmarshalErr(&v250v2, bs250, h, t, "dec-map-v250-p-nil")
+		testDeepEqualErr(v250v1, v250v2, t, "equal-map-v250-p-nil")
+		// ...
+		if v == nil {
+			v250v2 = nil
+		} else {
+			v250v2 = make(map[int32]float64, len(v))
+		} // reset map
+		var v250v3, v250v4 typMapMapInt32Float64
+		v250v3 = typMapMapInt32Float64(v250v1)
+		v250v4 = typMapMapInt32Float64(v250v2)
+		bs250 = testMarshalErr(v250v3, h, t, "enc-map-v250-custom")
+		testUnmarshalErr(v250v4, bs250, h, t, "dec-map-v250-p-len")
+		testDeepEqualErr(v250v3, v250v4, t, "equal-map-v250-p-len")
+	}
+
+	for _, v := range []map[int32]bool{nil, {}, {44: false, 33: true}} {
+		// fmt.Printf(">>>> running mammoth map v251: %v\n", v)
+		var v251v1, v251v2 map[int32]bool
+		v251v1 = v
+		bs251 := testMarshalErr(v251v1, h, t, "enc-map-v251")
+		if v == nil {
+			v251v2 = nil
+		} else {
+			v251v2 = make(map[int32]bool, len(v))
+		} // reset map
+		testUnmarshalErr(v251v2, bs251, h, t, "dec-map-v251")
+		testDeepEqualErr(v251v1, v251v2, t, "equal-map-v251")
+		if v == nil {
+			v251v2 = nil
+		} else {
+			v251v2 = make(map[int32]bool, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v251v2), bs251, h, t, "dec-map-v251-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v251v1, v251v2, t, "equal-map-v251-noaddr")
+		if v == nil {
+			v251v2 = nil
+		} else {
+			v251v2 = make(map[int32]bool, len(v))
+		} // reset map
+		testUnmarshalErr(&v251v2, bs251, h, t, "dec-map-v251-p-len")
+		testDeepEqualErr(v251v1, v251v2, t, "equal-map-v251-p-len")
+		bs251 = testMarshalErr(&v251v1, h, t, "enc-map-v251-p")
+		v251v2 = nil
+		testUnmarshalErr(&v251v2, bs251, h, t, "dec-map-v251-p-nil")
+		testDeepEqualErr(v251v1, v251v2, t, "equal-map-v251-p-nil")
+		// ...
+		if v == nil {
+			v251v2 = nil
+		} else {
+			v251v2 = make(map[int32]bool, len(v))
+		} // reset map
+		var v251v3, v251v4 typMapMapInt32Bool
+		v251v3 = typMapMapInt32Bool(v251v1)
+		v251v4 = typMapMapInt32Bool(v251v2)
+		bs251 = testMarshalErr(v251v3, h, t, "enc-map-v251-custom")
+		testUnmarshalErr(v251v4, bs251, h, t, "dec-map-v251-p-len")
+		testDeepEqualErr(v251v3, v251v4, t, "equal-map-v251-p-len")
+	}
+
+	for _, v := range []map[int64]interface{}{nil, {}, {44: nil, 33: "string-is-an-interface-2"}} {
+		// fmt.Printf(">>>> running mammoth map v254: %v\n", v)
+		var v254v1, v254v2 map[int64]interface{}
+		v254v1 = v
+		bs254 := testMarshalErr(v254v1, h, t, "enc-map-v254")
+		if v == nil {
+			v254v2 = nil
+		} else {
+			v254v2 = make(map[int64]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(v254v2, bs254, h, t, "dec-map-v254")
+		testDeepEqualErr(v254v1, v254v2, t, "equal-map-v254")
+		if v == nil {
+			v254v2 = nil
+		} else {
+			v254v2 = make(map[int64]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v254v2), bs254, h, t, "dec-map-v254-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v254v1, v254v2, t, "equal-map-v254-noaddr")
+		if v == nil {
+			v254v2 = nil
+		} else {
+			v254v2 = make(map[int64]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(&v254v2, bs254, h, t, "dec-map-v254-p-len")
+		testDeepEqualErr(v254v1, v254v2, t, "equal-map-v254-p-len")
+		bs254 = testMarshalErr(&v254v1, h, t, "enc-map-v254-p")
+		v254v2 = nil
+		testUnmarshalErr(&v254v2, bs254, h, t, "dec-map-v254-p-nil")
+		testDeepEqualErr(v254v1, v254v2, t, "equal-map-v254-p-nil")
+		// ...
+		if v == nil {
+			v254v2 = nil
+		} else {
+			v254v2 = make(map[int64]interface{}, len(v))
+		} // reset map
+		var v254v3, v254v4 typMapMapInt64Intf
+		v254v3 = typMapMapInt64Intf(v254v1)
+		v254v4 = typMapMapInt64Intf(v254v2)
+		bs254 = testMarshalErr(v254v3, h, t, "enc-map-v254-custom")
+		testUnmarshalErr(v254v4, bs254, h, t, "dec-map-v254-p-len")
+		testDeepEqualErr(v254v3, v254v4, t, "equal-map-v254-p-len")
+	}
+
+	for _, v := range []map[int64]string{nil, {}, {44: "", 33: "some-string-2"}} {
+		// fmt.Printf(">>>> running mammoth map v255: %v\n", v)
+		var v255v1, v255v2 map[int64]string
+		v255v1 = v
+		bs255 := testMarshalErr(v255v1, h, t, "enc-map-v255")
+		if v == nil {
+			v255v2 = nil
+		} else {
+			v255v2 = make(map[int64]string, len(v))
+		} // reset map
+		testUnmarshalErr(v255v2, bs255, h, t, "dec-map-v255")
+		testDeepEqualErr(v255v1, v255v2, t, "equal-map-v255")
+		if v == nil {
+			v255v2 = nil
+		} else {
+			v255v2 = make(map[int64]string, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v255v2), bs255, h, t, "dec-map-v255-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v255v1, v255v2, t, "equal-map-v255-noaddr")
+		if v == nil {
+			v255v2 = nil
+		} else {
+			v255v2 = make(map[int64]string, len(v))
+		} // reset map
+		testUnmarshalErr(&v255v2, bs255, h, t, "dec-map-v255-p-len")
+		testDeepEqualErr(v255v1, v255v2, t, "equal-map-v255-p-len")
+		bs255 = testMarshalErr(&v255v1, h, t, "enc-map-v255-p")
+		v255v2 = nil
+		testUnmarshalErr(&v255v2, bs255, h, t, "dec-map-v255-p-nil")
+		testDeepEqualErr(v255v1, v255v2, t, "equal-map-v255-p-nil")
+		// ...
+		if v == nil {
+			v255v2 = nil
+		} else {
+			v255v2 = make(map[int64]string, len(v))
+		} // reset map
+		var v255v3, v255v4 typMapMapInt64String
+		v255v3 = typMapMapInt64String(v255v1)
+		v255v4 = typMapMapInt64String(v255v2)
+		bs255 = testMarshalErr(v255v3, h, t, "enc-map-v255-custom")
+		testUnmarshalErr(v255v4, bs255, h, t, "dec-map-v255-p-len")
+		testDeepEqualErr(v255v3, v255v4, t, "equal-map-v255-p-len")
+	}
+
+	for _, v := range []map[int64]uint{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v256: %v\n", v)
+		var v256v1, v256v2 map[int64]uint
+		v256v1 = v
+		bs256 := testMarshalErr(v256v1, h, t, "enc-map-v256")
+		if v == nil {
+			v256v2 = nil
+		} else {
+			v256v2 = make(map[int64]uint, len(v))
+		} // reset map
+		testUnmarshalErr(v256v2, bs256, h, t, "dec-map-v256")
+		testDeepEqualErr(v256v1, v256v2, t, "equal-map-v256")
+		if v == nil {
+			v256v2 = nil
+		} else {
+			v256v2 = make(map[int64]uint, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v256v2), bs256, h, t, "dec-map-v256-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v256v1, v256v2, t, "equal-map-v256-noaddr")
+		if v == nil {
+			v256v2 = nil
+		} else {
+			v256v2 = make(map[int64]uint, len(v))
+		} // reset map
+		testUnmarshalErr(&v256v2, bs256, h, t, "dec-map-v256-p-len")
+		testDeepEqualErr(v256v1, v256v2, t, "equal-map-v256-p-len")
+		bs256 = testMarshalErr(&v256v1, h, t, "enc-map-v256-p")
+		v256v2 = nil
+		testUnmarshalErr(&v256v2, bs256, h, t, "dec-map-v256-p-nil")
+		testDeepEqualErr(v256v1, v256v2, t, "equal-map-v256-p-nil")
+		// ...
+		if v == nil {
+			v256v2 = nil
+		} else {
+			v256v2 = make(map[int64]uint, len(v))
+		} // reset map
+		var v256v3, v256v4 typMapMapInt64Uint
+		v256v3 = typMapMapInt64Uint(v256v1)
+		v256v4 = typMapMapInt64Uint(v256v2)
+		bs256 = testMarshalErr(v256v3, h, t, "enc-map-v256-custom")
+		testUnmarshalErr(v256v4, bs256, h, t, "dec-map-v256-p-len")
+		testDeepEqualErr(v256v3, v256v4, t, "equal-map-v256-p-len")
+	}
+
+	for _, v := range []map[int64]uint8{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v257: %v\n", v)
+		var v257v1, v257v2 map[int64]uint8
+		v257v1 = v
+		bs257 := testMarshalErr(v257v1, h, t, "enc-map-v257")
+		if v == nil {
+			v257v2 = nil
+		} else {
+			v257v2 = make(map[int64]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(v257v2, bs257, h, t, "dec-map-v257")
+		testDeepEqualErr(v257v1, v257v2, t, "equal-map-v257")
+		if v == nil {
+			v257v2 = nil
+		} else {
+			v257v2 = make(map[int64]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v257v2), bs257, h, t, "dec-map-v257-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v257v1, v257v2, t, "equal-map-v257-noaddr")
+		if v == nil {
+			v257v2 = nil
+		} else {
+			v257v2 = make(map[int64]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(&v257v2, bs257, h, t, "dec-map-v257-p-len")
+		testDeepEqualErr(v257v1, v257v2, t, "equal-map-v257-p-len")
+		bs257 = testMarshalErr(&v257v1, h, t, "enc-map-v257-p")
+		v257v2 = nil
+		testUnmarshalErr(&v257v2, bs257, h, t, "dec-map-v257-p-nil")
+		testDeepEqualErr(v257v1, v257v2, t, "equal-map-v257-p-nil")
+		// ...
+		if v == nil {
+			v257v2 = nil
+		} else {
+			v257v2 = make(map[int64]uint8, len(v))
+		} // reset map
+		var v257v3, v257v4 typMapMapInt64Uint8
+		v257v3 = typMapMapInt64Uint8(v257v1)
+		v257v4 = typMapMapInt64Uint8(v257v2)
+		bs257 = testMarshalErr(v257v3, h, t, "enc-map-v257-custom")
+		testUnmarshalErr(v257v4, bs257, h, t, "dec-map-v257-p-len")
+		testDeepEqualErr(v257v3, v257v4, t, "equal-map-v257-p-len")
+	}
+
+	for _, v := range []map[int64]uint16{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v258: %v\n", v)
+		var v258v1, v258v2 map[int64]uint16
+		v258v1 = v
+		bs258 := testMarshalErr(v258v1, h, t, "enc-map-v258")
+		if v == nil {
+			v258v2 = nil
+		} else {
+			v258v2 = make(map[int64]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(v258v2, bs258, h, t, "dec-map-v258")
+		testDeepEqualErr(v258v1, v258v2, t, "equal-map-v258")
+		if v == nil {
+			v258v2 = nil
+		} else {
+			v258v2 = make(map[int64]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v258v2), bs258, h, t, "dec-map-v258-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v258v1, v258v2, t, "equal-map-v258-noaddr")
+		if v == nil {
+			v258v2 = nil
+		} else {
+			v258v2 = make(map[int64]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(&v258v2, bs258, h, t, "dec-map-v258-p-len")
+		testDeepEqualErr(v258v1, v258v2, t, "equal-map-v258-p-len")
+		bs258 = testMarshalErr(&v258v1, h, t, "enc-map-v258-p")
+		v258v2 = nil
+		testUnmarshalErr(&v258v2, bs258, h, t, "dec-map-v258-p-nil")
+		testDeepEqualErr(v258v1, v258v2, t, "equal-map-v258-p-nil")
+		// ...
+		if v == nil {
+			v258v2 = nil
+		} else {
+			v258v2 = make(map[int64]uint16, len(v))
+		} // reset map
+		var v258v3, v258v4 typMapMapInt64Uint16
+		v258v3 = typMapMapInt64Uint16(v258v1)
+		v258v4 = typMapMapInt64Uint16(v258v2)
+		bs258 = testMarshalErr(v258v3, h, t, "enc-map-v258-custom")
+		testUnmarshalErr(v258v4, bs258, h, t, "dec-map-v258-p-len")
+		testDeepEqualErr(v258v3, v258v4, t, "equal-map-v258-p-len")
+	}
+
+	for _, v := range []map[int64]uint32{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v259: %v\n", v)
+		var v259v1, v259v2 map[int64]uint32
+		v259v1 = v
+		bs259 := testMarshalErr(v259v1, h, t, "enc-map-v259")
+		if v == nil {
+			v259v2 = nil
+		} else {
+			v259v2 = make(map[int64]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(v259v2, bs259, h, t, "dec-map-v259")
+		testDeepEqualErr(v259v1, v259v2, t, "equal-map-v259")
+		if v == nil {
+			v259v2 = nil
+		} else {
+			v259v2 = make(map[int64]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v259v2), bs259, h, t, "dec-map-v259-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v259v1, v259v2, t, "equal-map-v259-noaddr")
+		if v == nil {
+			v259v2 = nil
+		} else {
+			v259v2 = make(map[int64]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(&v259v2, bs259, h, t, "dec-map-v259-p-len")
+		testDeepEqualErr(v259v1, v259v2, t, "equal-map-v259-p-len")
+		bs259 = testMarshalErr(&v259v1, h, t, "enc-map-v259-p")
+		v259v2 = nil
+		testUnmarshalErr(&v259v2, bs259, h, t, "dec-map-v259-p-nil")
+		testDeepEqualErr(v259v1, v259v2, t, "equal-map-v259-p-nil")
+		// ...
+		if v == nil {
+			v259v2 = nil
+		} else {
+			v259v2 = make(map[int64]uint32, len(v))
+		} // reset map
+		var v259v3, v259v4 typMapMapInt64Uint32
+		v259v3 = typMapMapInt64Uint32(v259v1)
+		v259v4 = typMapMapInt64Uint32(v259v2)
+		bs259 = testMarshalErr(v259v3, h, t, "enc-map-v259-custom")
+		testUnmarshalErr(v259v4, bs259, h, t, "dec-map-v259-p-len")
+		testDeepEqualErr(v259v3, v259v4, t, "equal-map-v259-p-len")
+	}
+
+	for _, v := range []map[int64]uint64{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v260: %v\n", v)
+		var v260v1, v260v2 map[int64]uint64
+		v260v1 = v
+		bs260 := testMarshalErr(v260v1, h, t, "enc-map-v260")
+		if v == nil {
+			v260v2 = nil
+		} else {
+			v260v2 = make(map[int64]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(v260v2, bs260, h, t, "dec-map-v260")
+		testDeepEqualErr(v260v1, v260v2, t, "equal-map-v260")
+		if v == nil {
+			v260v2 = nil
+		} else {
+			v260v2 = make(map[int64]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v260v2), bs260, h, t, "dec-map-v260-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v260v1, v260v2, t, "equal-map-v260-noaddr")
+		if v == nil {
+			v260v2 = nil
+		} else {
+			v260v2 = make(map[int64]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(&v260v2, bs260, h, t, "dec-map-v260-p-len")
+		testDeepEqualErr(v260v1, v260v2, t, "equal-map-v260-p-len")
+		bs260 = testMarshalErr(&v260v1, h, t, "enc-map-v260-p")
+		v260v2 = nil
+		testUnmarshalErr(&v260v2, bs260, h, t, "dec-map-v260-p-nil")
+		testDeepEqualErr(v260v1, v260v2, t, "equal-map-v260-p-nil")
+		// ...
+		if v == nil {
+			v260v2 = nil
+		} else {
+			v260v2 = make(map[int64]uint64, len(v))
+		} // reset map
+		var v260v3, v260v4 typMapMapInt64Uint64
+		v260v3 = typMapMapInt64Uint64(v260v1)
+		v260v4 = typMapMapInt64Uint64(v260v2)
+		bs260 = testMarshalErr(v260v3, h, t, "enc-map-v260-custom")
+		testUnmarshalErr(v260v4, bs260, h, t, "dec-map-v260-p-len")
+		testDeepEqualErr(v260v3, v260v4, t, "equal-map-v260-p-len")
+	}
+
+	for _, v := range []map[int64]uintptr{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v261: %v\n", v)
+		var v261v1, v261v2 map[int64]uintptr
+		v261v1 = v
+		bs261 := testMarshalErr(v261v1, h, t, "enc-map-v261")
+		if v == nil {
+			v261v2 = nil
+		} else {
+			v261v2 = make(map[int64]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(v261v2, bs261, h, t, "dec-map-v261")
+		testDeepEqualErr(v261v1, v261v2, t, "equal-map-v261")
+		if v == nil {
+			v261v2 = nil
+		} else {
+			v261v2 = make(map[int64]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v261v2), bs261, h, t, "dec-map-v261-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v261v1, v261v2, t, "equal-map-v261-noaddr")
+		if v == nil {
+			v261v2 = nil
+		} else {
+			v261v2 = make(map[int64]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(&v261v2, bs261, h, t, "dec-map-v261-p-len")
+		testDeepEqualErr(v261v1, v261v2, t, "equal-map-v261-p-len")
+		bs261 = testMarshalErr(&v261v1, h, t, "enc-map-v261-p")
+		v261v2 = nil
+		testUnmarshalErr(&v261v2, bs261, h, t, "dec-map-v261-p-nil")
+		testDeepEqualErr(v261v1, v261v2, t, "equal-map-v261-p-nil")
+		// ...
+		if v == nil {
+			v261v2 = nil
+		} else {
+			v261v2 = make(map[int64]uintptr, len(v))
+		} // reset map
+		var v261v3, v261v4 typMapMapInt64Uintptr
+		v261v3 = typMapMapInt64Uintptr(v261v1)
+		v261v4 = typMapMapInt64Uintptr(v261v2)
+		bs261 = testMarshalErr(v261v3, h, t, "enc-map-v261-custom")
+		testUnmarshalErr(v261v4, bs261, h, t, "dec-map-v261-p-len")
+		testDeepEqualErr(v261v3, v261v4, t, "equal-map-v261-p-len")
+	}
+
+	for _, v := range []map[int64]int{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v262: %v\n", v)
+		var v262v1, v262v2 map[int64]int
+		v262v1 = v
+		bs262 := testMarshalErr(v262v1, h, t, "enc-map-v262")
+		if v == nil {
+			v262v2 = nil
+		} else {
+			v262v2 = make(map[int64]int, len(v))
+		} // reset map
+		testUnmarshalErr(v262v2, bs262, h, t, "dec-map-v262")
+		testDeepEqualErr(v262v1, v262v2, t, "equal-map-v262")
+		if v == nil {
+			v262v2 = nil
+		} else {
+			v262v2 = make(map[int64]int, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v262v2), bs262, h, t, "dec-map-v262-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v262v1, v262v2, t, "equal-map-v262-noaddr")
+		if v == nil {
+			v262v2 = nil
+		} else {
+			v262v2 = make(map[int64]int, len(v))
+		} // reset map
+		testUnmarshalErr(&v262v2, bs262, h, t, "dec-map-v262-p-len")
+		testDeepEqualErr(v262v1, v262v2, t, "equal-map-v262-p-len")
+		bs262 = testMarshalErr(&v262v1, h, t, "enc-map-v262-p")
+		v262v2 = nil
+		testUnmarshalErr(&v262v2, bs262, h, t, "dec-map-v262-p-nil")
+		testDeepEqualErr(v262v1, v262v2, t, "equal-map-v262-p-nil")
+		// ...
+		if v == nil {
+			v262v2 = nil
+		} else {
+			v262v2 = make(map[int64]int, len(v))
+		} // reset map
+		var v262v3, v262v4 typMapMapInt64Int
+		v262v3 = typMapMapInt64Int(v262v1)
+		v262v4 = typMapMapInt64Int(v262v2)
+		bs262 = testMarshalErr(v262v3, h, t, "enc-map-v262-custom")
+		testUnmarshalErr(v262v4, bs262, h, t, "dec-map-v262-p-len")
+		testDeepEqualErr(v262v3, v262v4, t, "equal-map-v262-p-len")
+	}
+
+	for _, v := range []map[int64]int8{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v263: %v\n", v)
+		var v263v1, v263v2 map[int64]int8
+		v263v1 = v
+		bs263 := testMarshalErr(v263v1, h, t, "enc-map-v263")
+		if v == nil {
+			v263v2 = nil
+		} else {
+			v263v2 = make(map[int64]int8, len(v))
+		} // reset map
+		testUnmarshalErr(v263v2, bs263, h, t, "dec-map-v263")
+		testDeepEqualErr(v263v1, v263v2, t, "equal-map-v263")
+		if v == nil {
+			v263v2 = nil
+		} else {
+			v263v2 = make(map[int64]int8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v263v2), bs263, h, t, "dec-map-v263-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v263v1, v263v2, t, "equal-map-v263-noaddr")
+		if v == nil {
+			v263v2 = nil
+		} else {
+			v263v2 = make(map[int64]int8, len(v))
+		} // reset map
+		testUnmarshalErr(&v263v2, bs263, h, t, "dec-map-v263-p-len")
+		testDeepEqualErr(v263v1, v263v2, t, "equal-map-v263-p-len")
+		bs263 = testMarshalErr(&v263v1, h, t, "enc-map-v263-p")
+		v263v2 = nil
+		testUnmarshalErr(&v263v2, bs263, h, t, "dec-map-v263-p-nil")
+		testDeepEqualErr(v263v1, v263v2, t, "equal-map-v263-p-nil")
+		// ...
+		if v == nil {
+			v263v2 = nil
+		} else {
+			v263v2 = make(map[int64]int8, len(v))
+		} // reset map
+		var v263v3, v263v4 typMapMapInt64Int8
+		v263v3 = typMapMapInt64Int8(v263v1)
+		v263v4 = typMapMapInt64Int8(v263v2)
+		bs263 = testMarshalErr(v263v3, h, t, "enc-map-v263-custom")
+		testUnmarshalErr(v263v4, bs263, h, t, "dec-map-v263-p-len")
+		testDeepEqualErr(v263v3, v263v4, t, "equal-map-v263-p-len")
+	}
+
+	for _, v := range []map[int64]int16{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v264: %v\n", v)
+		var v264v1, v264v2 map[int64]int16
+		v264v1 = v
+		bs264 := testMarshalErr(v264v1, h, t, "enc-map-v264")
+		if v == nil {
+			v264v2 = nil
+		} else {
+			v264v2 = make(map[int64]int16, len(v))
+		} // reset map
+		testUnmarshalErr(v264v2, bs264, h, t, "dec-map-v264")
+		testDeepEqualErr(v264v1, v264v2, t, "equal-map-v264")
+		if v == nil {
+			v264v2 = nil
+		} else {
+			v264v2 = make(map[int64]int16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v264v2), bs264, h, t, "dec-map-v264-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v264v1, v264v2, t, "equal-map-v264-noaddr")
+		if v == nil {
+			v264v2 = nil
+		} else {
+			v264v2 = make(map[int64]int16, len(v))
+		} // reset map
+		testUnmarshalErr(&v264v2, bs264, h, t, "dec-map-v264-p-len")
+		testDeepEqualErr(v264v1, v264v2, t, "equal-map-v264-p-len")
+		bs264 = testMarshalErr(&v264v1, h, t, "enc-map-v264-p")
+		v264v2 = nil
+		testUnmarshalErr(&v264v2, bs264, h, t, "dec-map-v264-p-nil")
+		testDeepEqualErr(v264v1, v264v2, t, "equal-map-v264-p-nil")
+		// ...
+		if v == nil {
+			v264v2 = nil
+		} else {
+			v264v2 = make(map[int64]int16, len(v))
+		} // reset map
+		var v264v3, v264v4 typMapMapInt64Int16
+		v264v3 = typMapMapInt64Int16(v264v1)
+		v264v4 = typMapMapInt64Int16(v264v2)
+		bs264 = testMarshalErr(v264v3, h, t, "enc-map-v264-custom")
+		testUnmarshalErr(v264v4, bs264, h, t, "dec-map-v264-p-len")
+		testDeepEqualErr(v264v3, v264v4, t, "equal-map-v264-p-len")
+	}
+
+	for _, v := range []map[int64]int32{nil, {}, {33: 0, 44: 33}} {
+		// fmt.Printf(">>>> running mammoth map v265: %v\n", v)
+		var v265v1, v265v2 map[int64]int32
+		v265v1 = v
+		bs265 := testMarshalErr(v265v1, h, t, "enc-map-v265")
+		if v == nil {
+			v265v2 = nil
+		} else {
+			v265v2 = make(map[int64]int32, len(v))
+		} // reset map
+		testUnmarshalErr(v265v2, bs265, h, t, "dec-map-v265")
+		testDeepEqualErr(v265v1, v265v2, t, "equal-map-v265")
+		if v == nil {
+			v265v2 = nil
+		} else {
+			v265v2 = make(map[int64]int32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v265v2), bs265, h, t, "dec-map-v265-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v265v1, v265v2, t, "equal-map-v265-noaddr")
+		if v == nil {
+			v265v2 = nil
+		} else {
+			v265v2 = make(map[int64]int32, len(v))
+		} // reset map
+		testUnmarshalErr(&v265v2, bs265, h, t, "dec-map-v265-p-len")
+		testDeepEqualErr(v265v1, v265v2, t, "equal-map-v265-p-len")
+		bs265 = testMarshalErr(&v265v1, h, t, "enc-map-v265-p")
+		v265v2 = nil
+		testUnmarshalErr(&v265v2, bs265, h, t, "dec-map-v265-p-nil")
+		testDeepEqualErr(v265v1, v265v2, t, "equal-map-v265-p-nil")
+		// ...
+		if v == nil {
+			v265v2 = nil
+		} else {
+			v265v2 = make(map[int64]int32, len(v))
+		} // reset map
+		var v265v3, v265v4 typMapMapInt64Int32
+		v265v3 = typMapMapInt64Int32(v265v1)
+		v265v4 = typMapMapInt64Int32(v265v2)
+		bs265 = testMarshalErr(v265v3, h, t, "enc-map-v265-custom")
+		testUnmarshalErr(v265v4, bs265, h, t, "dec-map-v265-p-len")
+		testDeepEqualErr(v265v3, v265v4, t, "equal-map-v265-p-len")
+	}
+
+	for _, v := range []map[int64]int64{nil, {}, {44: 0, 33: 44}} {
+		// fmt.Printf(">>>> running mammoth map v266: %v\n", v)
+		var v266v1, v266v2 map[int64]int64
+		v266v1 = v
+		bs266 := testMarshalErr(v266v1, h, t, "enc-map-v266")
+		if v == nil {
+			v266v2 = nil
+		} else {
+			v266v2 = make(map[int64]int64, len(v))
+		} // reset map
+		testUnmarshalErr(v266v2, bs266, h, t, "dec-map-v266")
+		testDeepEqualErr(v266v1, v266v2, t, "equal-map-v266")
+		if v == nil {
+			v266v2 = nil
+		} else {
+			v266v2 = make(map[int64]int64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v266v2), bs266, h, t, "dec-map-v266-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v266v1, v266v2, t, "equal-map-v266-noaddr")
+		if v == nil {
+			v266v2 = nil
+		} else {
+			v266v2 = make(map[int64]int64, len(v))
+		} // reset map
+		testUnmarshalErr(&v266v2, bs266, h, t, "dec-map-v266-p-len")
+		testDeepEqualErr(v266v1, v266v2, t, "equal-map-v266-p-len")
+		bs266 = testMarshalErr(&v266v1, h, t, "enc-map-v266-p")
+		v266v2 = nil
+		testUnmarshalErr(&v266v2, bs266, h, t, "dec-map-v266-p-nil")
+		testDeepEqualErr(v266v1, v266v2, t, "equal-map-v266-p-nil")
+		// ...
+		if v == nil {
+			v266v2 = nil
+		} else {
+			v266v2 = make(map[int64]int64, len(v))
+		} // reset map
+		var v266v3, v266v4 typMapMapInt64Int64
+		v266v3 = typMapMapInt64Int64(v266v1)
+		v266v4 = typMapMapInt64Int64(v266v2)
+		bs266 = testMarshalErr(v266v3, h, t, "enc-map-v266-custom")
+		testUnmarshalErr(v266v4, bs266, h, t, "dec-map-v266-p-len")
+		testDeepEqualErr(v266v3, v266v4, t, "equal-map-v266-p-len")
+	}
+
+	for _, v := range []map[int64]float32{nil, {}, {33: 0, 44: 22.2}} {
+		// fmt.Printf(">>>> running mammoth map v267: %v\n", v)
+		var v267v1, v267v2 map[int64]float32
+		v267v1 = v
+		bs267 := testMarshalErr(v267v1, h, t, "enc-map-v267")
+		if v == nil {
+			v267v2 = nil
+		} else {
+			v267v2 = make(map[int64]float32, len(v))
+		} // reset map
+		testUnmarshalErr(v267v2, bs267, h, t, "dec-map-v267")
+		testDeepEqualErr(v267v1, v267v2, t, "equal-map-v267")
+		if v == nil {
+			v267v2 = nil
+		} else {
+			v267v2 = make(map[int64]float32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v267v2), bs267, h, t, "dec-map-v267-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v267v1, v267v2, t, "equal-map-v267-noaddr")
+		if v == nil {
+			v267v2 = nil
+		} else {
+			v267v2 = make(map[int64]float32, len(v))
+		} // reset map
+		testUnmarshalErr(&v267v2, bs267, h, t, "dec-map-v267-p-len")
+		testDeepEqualErr(v267v1, v267v2, t, "equal-map-v267-p-len")
+		bs267 = testMarshalErr(&v267v1, h, t, "enc-map-v267-p")
+		v267v2 = nil
+		testUnmarshalErr(&v267v2, bs267, h, t, "dec-map-v267-p-nil")
+		testDeepEqualErr(v267v1, v267v2, t, "equal-map-v267-p-nil")
+		// ...
+		if v == nil {
+			v267v2 = nil
+		} else {
+			v267v2 = make(map[int64]float32, len(v))
+		} // reset map
+		var v267v3, v267v4 typMapMapInt64Float32
+		v267v3 = typMapMapInt64Float32(v267v1)
+		v267v4 = typMapMapInt64Float32(v267v2)
+		bs267 = testMarshalErr(v267v3, h, t, "enc-map-v267-custom")
+		testUnmarshalErr(v267v4, bs267, h, t, "dec-map-v267-p-len")
+		testDeepEqualErr(v267v3, v267v4, t, "equal-map-v267-p-len")
+	}
+
+	for _, v := range []map[int64]float64{nil, {}, {33: 0, 44: 11.1}} {
+		// fmt.Printf(">>>> running mammoth map v268: %v\n", v)
+		var v268v1, v268v2 map[int64]float64
+		v268v1 = v
+		bs268 := testMarshalErr(v268v1, h, t, "enc-map-v268")
+		if v == nil {
+			v268v2 = nil
+		} else {
+			v268v2 = make(map[int64]float64, len(v))
+		} // reset map
+		testUnmarshalErr(v268v2, bs268, h, t, "dec-map-v268")
+		testDeepEqualErr(v268v1, v268v2, t, "equal-map-v268")
+		if v == nil {
+			v268v2 = nil
+		} else {
+			v268v2 = make(map[int64]float64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v268v2), bs268, h, t, "dec-map-v268-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v268v1, v268v2, t, "equal-map-v268-noaddr")
+		if v == nil {
+			v268v2 = nil
+		} else {
+			v268v2 = make(map[int64]float64, len(v))
+		} // reset map
+		testUnmarshalErr(&v268v2, bs268, h, t, "dec-map-v268-p-len")
+		testDeepEqualErr(v268v1, v268v2, t, "equal-map-v268-p-len")
+		bs268 = testMarshalErr(&v268v1, h, t, "enc-map-v268-p")
+		v268v2 = nil
+		testUnmarshalErr(&v268v2, bs268, h, t, "dec-map-v268-p-nil")
+		testDeepEqualErr(v268v1, v268v2, t, "equal-map-v268-p-nil")
+		// ...
+		if v == nil {
+			v268v2 = nil
+		} else {
+			v268v2 = make(map[int64]float64, len(v))
+		} // reset map
+		var v268v3, v268v4 typMapMapInt64Float64
+		v268v3 = typMapMapInt64Float64(v268v1)
+		v268v4 = typMapMapInt64Float64(v268v2)
+		bs268 = testMarshalErr(v268v3, h, t, "enc-map-v268-custom")
+		testUnmarshalErr(v268v4, bs268, h, t, "dec-map-v268-p-len")
+		testDeepEqualErr(v268v3, v268v4, t, "equal-map-v268-p-len")
+	}
+
+	for _, v := range []map[int64]bool{nil, {}, {33: false, 44: true}} {
+		// fmt.Printf(">>>> running mammoth map v269: %v\n", v)
+		var v269v1, v269v2 map[int64]bool
+		v269v1 = v
+		bs269 := testMarshalErr(v269v1, h, t, "enc-map-v269")
+		if v == nil {
+			v269v2 = nil
+		} else {
+			v269v2 = make(map[int64]bool, len(v))
+		} // reset map
+		testUnmarshalErr(v269v2, bs269, h, t, "dec-map-v269")
+		testDeepEqualErr(v269v1, v269v2, t, "equal-map-v269")
+		if v == nil {
+			v269v2 = nil
+		} else {
+			v269v2 = make(map[int64]bool, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v269v2), bs269, h, t, "dec-map-v269-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v269v1, v269v2, t, "equal-map-v269-noaddr")
+		if v == nil {
+			v269v2 = nil
+		} else {
+			v269v2 = make(map[int64]bool, len(v))
+		} // reset map
+		testUnmarshalErr(&v269v2, bs269, h, t, "dec-map-v269-p-len")
+		testDeepEqualErr(v269v1, v269v2, t, "equal-map-v269-p-len")
+		bs269 = testMarshalErr(&v269v1, h, t, "enc-map-v269-p")
+		v269v2 = nil
+		testUnmarshalErr(&v269v2, bs269, h, t, "dec-map-v269-p-nil")
+		testDeepEqualErr(v269v1, v269v2, t, "equal-map-v269-p-nil")
+		// ...
+		if v == nil {
+			v269v2 = nil
+		} else {
+			v269v2 = make(map[int64]bool, len(v))
+		} // reset map
+		var v269v3, v269v4 typMapMapInt64Bool
+		v269v3 = typMapMapInt64Bool(v269v1)
+		v269v4 = typMapMapInt64Bool(v269v2)
+		bs269 = testMarshalErr(v269v3, h, t, "enc-map-v269-custom")
+		testUnmarshalErr(v269v4, bs269, h, t, "dec-map-v269-p-len")
+		testDeepEqualErr(v269v3, v269v4, t, "equal-map-v269-p-len")
+	}
+
+	for _, v := range []map[bool]interface{}{nil, {}, {true: nil}} {
+		// fmt.Printf(">>>> running mammoth map v272: %v\n", v)
+		var v272v1, v272v2 map[bool]interface{}
+		v272v1 = v
+		bs272 := testMarshalErr(v272v1, h, t, "enc-map-v272")
+		if v == nil {
+			v272v2 = nil
+		} else {
+			v272v2 = make(map[bool]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(v272v2, bs272, h, t, "dec-map-v272")
+		testDeepEqualErr(v272v1, v272v2, t, "equal-map-v272")
+		if v == nil {
+			v272v2 = nil
+		} else {
+			v272v2 = make(map[bool]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v272v2), bs272, h, t, "dec-map-v272-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v272v1, v272v2, t, "equal-map-v272-noaddr")
+		if v == nil {
+			v272v2 = nil
+		} else {
+			v272v2 = make(map[bool]interface{}, len(v))
+		} // reset map
+		testUnmarshalErr(&v272v2, bs272, h, t, "dec-map-v272-p-len")
+		testDeepEqualErr(v272v1, v272v2, t, "equal-map-v272-p-len")
+		bs272 = testMarshalErr(&v272v1, h, t, "enc-map-v272-p")
+		v272v2 = nil
+		testUnmarshalErr(&v272v2, bs272, h, t, "dec-map-v272-p-nil")
+		testDeepEqualErr(v272v1, v272v2, t, "equal-map-v272-p-nil")
+		// ...
+		if v == nil {
+			v272v2 = nil
+		} else {
+			v272v2 = make(map[bool]interface{}, len(v))
+		} // reset map
+		var v272v3, v272v4 typMapMapBoolIntf
+		v272v3 = typMapMapBoolIntf(v272v1)
+		v272v4 = typMapMapBoolIntf(v272v2)
+		bs272 = testMarshalErr(v272v3, h, t, "enc-map-v272-custom")
+		testUnmarshalErr(v272v4, bs272, h, t, "dec-map-v272-p-len")
+		testDeepEqualErr(v272v3, v272v4, t, "equal-map-v272-p-len")
+	}
+
+	for _, v := range []map[bool]string{nil, {}, {true: ""}} {
+		// fmt.Printf(">>>> running mammoth map v273: %v\n", v)
+		var v273v1, v273v2 map[bool]string
+		v273v1 = v
+		bs273 := testMarshalErr(v273v1, h, t, "enc-map-v273")
+		if v == nil {
+			v273v2 = nil
+		} else {
+			v273v2 = make(map[bool]string, len(v))
+		} // reset map
+		testUnmarshalErr(v273v2, bs273, h, t, "dec-map-v273")
+		testDeepEqualErr(v273v1, v273v2, t, "equal-map-v273")
+		if v == nil {
+			v273v2 = nil
+		} else {
+			v273v2 = make(map[bool]string, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v273v2), bs273, h, t, "dec-map-v273-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v273v1, v273v2, t, "equal-map-v273-noaddr")
+		if v == nil {
+			v273v2 = nil
+		} else {
+			v273v2 = make(map[bool]string, len(v))
+		} // reset map
+		testUnmarshalErr(&v273v2, bs273, h, t, "dec-map-v273-p-len")
+		testDeepEqualErr(v273v1, v273v2, t, "equal-map-v273-p-len")
+		bs273 = testMarshalErr(&v273v1, h, t, "enc-map-v273-p")
+		v273v2 = nil
+		testUnmarshalErr(&v273v2, bs273, h, t, "dec-map-v273-p-nil")
+		testDeepEqualErr(v273v1, v273v2, t, "equal-map-v273-p-nil")
+		// ...
+		if v == nil {
+			v273v2 = nil
+		} else {
+			v273v2 = make(map[bool]string, len(v))
+		} // reset map
+		var v273v3, v273v4 typMapMapBoolString
+		v273v3 = typMapMapBoolString(v273v1)
+		v273v4 = typMapMapBoolString(v273v2)
+		bs273 = testMarshalErr(v273v3, h, t, "enc-map-v273-custom")
+		testUnmarshalErr(v273v4, bs273, h, t, "dec-map-v273-p-len")
+		testDeepEqualErr(v273v3, v273v4, t, "equal-map-v273-p-len")
+	}
+
+	for _, v := range []map[bool]uint{nil, {}, {true: 0}} {
+		// fmt.Printf(">>>> running mammoth map v274: %v\n", v)
+		var v274v1, v274v2 map[bool]uint
+		v274v1 = v
+		bs274 := testMarshalErr(v274v1, h, t, "enc-map-v274")
+		if v == nil {
+			v274v2 = nil
+		} else {
+			v274v2 = make(map[bool]uint, len(v))
+		} // reset map
+		testUnmarshalErr(v274v2, bs274, h, t, "dec-map-v274")
+		testDeepEqualErr(v274v1, v274v2, t, "equal-map-v274")
+		if v == nil {
+			v274v2 = nil
+		} else {
+			v274v2 = make(map[bool]uint, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v274v2), bs274, h, t, "dec-map-v274-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v274v1, v274v2, t, "equal-map-v274-noaddr")
+		if v == nil {
+			v274v2 = nil
+		} else {
+			v274v2 = make(map[bool]uint, len(v))
+		} // reset map
+		testUnmarshalErr(&v274v2, bs274, h, t, "dec-map-v274-p-len")
+		testDeepEqualErr(v274v1, v274v2, t, "equal-map-v274-p-len")
+		bs274 = testMarshalErr(&v274v1, h, t, "enc-map-v274-p")
+		v274v2 = nil
+		testUnmarshalErr(&v274v2, bs274, h, t, "dec-map-v274-p-nil")
+		testDeepEqualErr(v274v1, v274v2, t, "equal-map-v274-p-nil")
+		// ...
+		if v == nil {
+			v274v2 = nil
+		} else {
+			v274v2 = make(map[bool]uint, len(v))
+		} // reset map
+		var v274v3, v274v4 typMapMapBoolUint
+		v274v3 = typMapMapBoolUint(v274v1)
+		v274v4 = typMapMapBoolUint(v274v2)
+		bs274 = testMarshalErr(v274v3, h, t, "enc-map-v274-custom")
+		testUnmarshalErr(v274v4, bs274, h, t, "dec-map-v274-p-len")
+		testDeepEqualErr(v274v3, v274v4, t, "equal-map-v274-p-len")
+	}
+
+	for _, v := range []map[bool]uint8{nil, {}, {true: 0}} {
+		// fmt.Printf(">>>> running mammoth map v275: %v\n", v)
+		var v275v1, v275v2 map[bool]uint8
+		v275v1 = v
+		bs275 := testMarshalErr(v275v1, h, t, "enc-map-v275")
+		if v == nil {
+			v275v2 = nil
+		} else {
+			v275v2 = make(map[bool]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(v275v2, bs275, h, t, "dec-map-v275")
+		testDeepEqualErr(v275v1, v275v2, t, "equal-map-v275")
+		if v == nil {
+			v275v2 = nil
+		} else {
+			v275v2 = make(map[bool]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v275v2), bs275, h, t, "dec-map-v275-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v275v1, v275v2, t, "equal-map-v275-noaddr")
+		if v == nil {
+			v275v2 = nil
+		} else {
+			v275v2 = make(map[bool]uint8, len(v))
+		} // reset map
+		testUnmarshalErr(&v275v2, bs275, h, t, "dec-map-v275-p-len")
+		testDeepEqualErr(v275v1, v275v2, t, "equal-map-v275-p-len")
+		bs275 = testMarshalErr(&v275v1, h, t, "enc-map-v275-p")
+		v275v2 = nil
+		testUnmarshalErr(&v275v2, bs275, h, t, "dec-map-v275-p-nil")
+		testDeepEqualErr(v275v1, v275v2, t, "equal-map-v275-p-nil")
+		// ...
+		if v == nil {
+			v275v2 = nil
+		} else {
+			v275v2 = make(map[bool]uint8, len(v))
+		} // reset map
+		var v275v3, v275v4 typMapMapBoolUint8
+		v275v3 = typMapMapBoolUint8(v275v1)
+		v275v4 = typMapMapBoolUint8(v275v2)
+		bs275 = testMarshalErr(v275v3, h, t, "enc-map-v275-custom")
+		testUnmarshalErr(v275v4, bs275, h, t, "dec-map-v275-p-len")
+		testDeepEqualErr(v275v3, v275v4, t, "equal-map-v275-p-len")
+	}
+
+	for _, v := range []map[bool]uint16{nil, {}, {true: 0}} {
+		// fmt.Printf(">>>> running mammoth map v276: %v\n", v)
+		var v276v1, v276v2 map[bool]uint16
+		v276v1 = v
+		bs276 := testMarshalErr(v276v1, h, t, "enc-map-v276")
+		if v == nil {
+			v276v2 = nil
+		} else {
+			v276v2 = make(map[bool]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(v276v2, bs276, h, t, "dec-map-v276")
+		testDeepEqualErr(v276v1, v276v2, t, "equal-map-v276")
+		if v == nil {
+			v276v2 = nil
+		} else {
+			v276v2 = make(map[bool]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v276v2), bs276, h, t, "dec-map-v276-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v276v1, v276v2, t, "equal-map-v276-noaddr")
+		if v == nil {
+			v276v2 = nil
+		} else {
+			v276v2 = make(map[bool]uint16, len(v))
+		} // reset map
+		testUnmarshalErr(&v276v2, bs276, h, t, "dec-map-v276-p-len")
+		testDeepEqualErr(v276v1, v276v2, t, "equal-map-v276-p-len")
+		bs276 = testMarshalErr(&v276v1, h, t, "enc-map-v276-p")
+		v276v2 = nil
+		testUnmarshalErr(&v276v2, bs276, h, t, "dec-map-v276-p-nil")
+		testDeepEqualErr(v276v1, v276v2, t, "equal-map-v276-p-nil")
+		// ...
+		if v == nil {
+			v276v2 = nil
+		} else {
+			v276v2 = make(map[bool]uint16, len(v))
+		} // reset map
+		var v276v3, v276v4 typMapMapBoolUint16
+		v276v3 = typMapMapBoolUint16(v276v1)
+		v276v4 = typMapMapBoolUint16(v276v2)
+		bs276 = testMarshalErr(v276v3, h, t, "enc-map-v276-custom")
+		testUnmarshalErr(v276v4, bs276, h, t, "dec-map-v276-p-len")
+		testDeepEqualErr(v276v3, v276v4, t, "equal-map-v276-p-len")
+	}
+
+	for _, v := range []map[bool]uint32{nil, {}, {true: 0}} {
+		// fmt.Printf(">>>> running mammoth map v277: %v\n", v)
+		var v277v1, v277v2 map[bool]uint32
+		v277v1 = v
+		bs277 := testMarshalErr(v277v1, h, t, "enc-map-v277")
+		if v == nil {
+			v277v2 = nil
+		} else {
+			v277v2 = make(map[bool]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(v277v2, bs277, h, t, "dec-map-v277")
+		testDeepEqualErr(v277v1, v277v2, t, "equal-map-v277")
+		if v == nil {
+			v277v2 = nil
+		} else {
+			v277v2 = make(map[bool]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v277v2), bs277, h, t, "dec-map-v277-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v277v1, v277v2, t, "equal-map-v277-noaddr")
+		if v == nil {
+			v277v2 = nil
+		} else {
+			v277v2 = make(map[bool]uint32, len(v))
+		} // reset map
+		testUnmarshalErr(&v277v2, bs277, h, t, "dec-map-v277-p-len")
+		testDeepEqualErr(v277v1, v277v2, t, "equal-map-v277-p-len")
+		bs277 = testMarshalErr(&v277v1, h, t, "enc-map-v277-p")
+		v277v2 = nil
+		testUnmarshalErr(&v277v2, bs277, h, t, "dec-map-v277-p-nil")
+		testDeepEqualErr(v277v1, v277v2, t, "equal-map-v277-p-nil")
+		// ...
+		if v == nil {
+			v277v2 = nil
+		} else {
+			v277v2 = make(map[bool]uint32, len(v))
+		} // reset map
+		var v277v3, v277v4 typMapMapBoolUint32
+		v277v3 = typMapMapBoolUint32(v277v1)
+		v277v4 = typMapMapBoolUint32(v277v2)
+		bs277 = testMarshalErr(v277v3, h, t, "enc-map-v277-custom")
+		testUnmarshalErr(v277v4, bs277, h, t, "dec-map-v277-p-len")
+		testDeepEqualErr(v277v3, v277v4, t, "equal-map-v277-p-len")
+	}
+
+	for _, v := range []map[bool]uint64{nil, {}, {true: 0}} {
+		// fmt.Printf(">>>> running mammoth map v278: %v\n", v)
+		var v278v1, v278v2 map[bool]uint64
+		v278v1 = v
+		bs278 := testMarshalErr(v278v1, h, t, "enc-map-v278")
+		if v == nil {
+			v278v2 = nil
+		} else {
+			v278v2 = make(map[bool]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(v278v2, bs278, h, t, "dec-map-v278")
+		testDeepEqualErr(v278v1, v278v2, t, "equal-map-v278")
+		if v == nil {
+			v278v2 = nil
+		} else {
+			v278v2 = make(map[bool]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v278v2), bs278, h, t, "dec-map-v278-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v278v1, v278v2, t, "equal-map-v278-noaddr")
+		if v == nil {
+			v278v2 = nil
+		} else {
+			v278v2 = make(map[bool]uint64, len(v))
+		} // reset map
+		testUnmarshalErr(&v278v2, bs278, h, t, "dec-map-v278-p-len")
+		testDeepEqualErr(v278v1, v278v2, t, "equal-map-v278-p-len")
+		bs278 = testMarshalErr(&v278v1, h, t, "enc-map-v278-p")
+		v278v2 = nil
+		testUnmarshalErr(&v278v2, bs278, h, t, "dec-map-v278-p-nil")
+		testDeepEqualErr(v278v1, v278v2, t, "equal-map-v278-p-nil")
+		// ...
+		if v == nil {
+			v278v2 = nil
+		} else {
+			v278v2 = make(map[bool]uint64, len(v))
+		} // reset map
+		var v278v3, v278v4 typMapMapBoolUint64
+		v278v3 = typMapMapBoolUint64(v278v1)
+		v278v4 = typMapMapBoolUint64(v278v2)
+		bs278 = testMarshalErr(v278v3, h, t, "enc-map-v278-custom")
+		testUnmarshalErr(v278v4, bs278, h, t, "dec-map-v278-p-len")
+		testDeepEqualErr(v278v3, v278v4, t, "equal-map-v278-p-len")
+	}
+
+	for _, v := range []map[bool]uintptr{nil, {}, {true: 0}} {
+		// fmt.Printf(">>>> running mammoth map v279: %v\n", v)
+		var v279v1, v279v2 map[bool]uintptr
+		v279v1 = v
+		bs279 := testMarshalErr(v279v1, h, t, "enc-map-v279")
+		if v == nil {
+			v279v2 = nil
+		} else {
+			v279v2 = make(map[bool]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(v279v2, bs279, h, t, "dec-map-v279")
+		testDeepEqualErr(v279v1, v279v2, t, "equal-map-v279")
+		if v == nil {
+			v279v2 = nil
+		} else {
+			v279v2 = make(map[bool]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v279v2), bs279, h, t, "dec-map-v279-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v279v1, v279v2, t, "equal-map-v279-noaddr")
+		if v == nil {
+			v279v2 = nil
+		} else {
+			v279v2 = make(map[bool]uintptr, len(v))
+		} // reset map
+		testUnmarshalErr(&v279v2, bs279, h, t, "dec-map-v279-p-len")
+		testDeepEqualErr(v279v1, v279v2, t, "equal-map-v279-p-len")
+		bs279 = testMarshalErr(&v279v1, h, t, "enc-map-v279-p")
+		v279v2 = nil
+		testUnmarshalErr(&v279v2, bs279, h, t, "dec-map-v279-p-nil")
+		testDeepEqualErr(v279v1, v279v2, t, "equal-map-v279-p-nil")
+		// ...
+		if v == nil {
+			v279v2 = nil
+		} else {
+			v279v2 = make(map[bool]uintptr, len(v))
+		} // reset map
+		var v279v3, v279v4 typMapMapBoolUintptr
+		v279v3 = typMapMapBoolUintptr(v279v1)
+		v279v4 = typMapMapBoolUintptr(v279v2)
+		bs279 = testMarshalErr(v279v3, h, t, "enc-map-v279-custom")
+		testUnmarshalErr(v279v4, bs279, h, t, "dec-map-v279-p-len")
+		testDeepEqualErr(v279v3, v279v4, t, "equal-map-v279-p-len")
+	}
+
+	for _, v := range []map[bool]int{nil, {}, {true: 0}} {
+		// fmt.Printf(">>>> running mammoth map v280: %v\n", v)
+		var v280v1, v280v2 map[bool]int
+		v280v1 = v
+		bs280 := testMarshalErr(v280v1, h, t, "enc-map-v280")
+		if v == nil {
+			v280v2 = nil
+		} else {
+			v280v2 = make(map[bool]int, len(v))
+		} // reset map
+		testUnmarshalErr(v280v2, bs280, h, t, "dec-map-v280")
+		testDeepEqualErr(v280v1, v280v2, t, "equal-map-v280")
+		if v == nil {
+			v280v2 = nil
+		} else {
+			v280v2 = make(map[bool]int, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v280v2), bs280, h, t, "dec-map-v280-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v280v1, v280v2, t, "equal-map-v280-noaddr")
+		if v == nil {
+			v280v2 = nil
+		} else {
+			v280v2 = make(map[bool]int, len(v))
+		} // reset map
+		testUnmarshalErr(&v280v2, bs280, h, t, "dec-map-v280-p-len")
+		testDeepEqualErr(v280v1, v280v2, t, "equal-map-v280-p-len")
+		bs280 = testMarshalErr(&v280v1, h, t, "enc-map-v280-p")
+		v280v2 = nil
+		testUnmarshalErr(&v280v2, bs280, h, t, "dec-map-v280-p-nil")
+		testDeepEqualErr(v280v1, v280v2, t, "equal-map-v280-p-nil")
+		// ...
+		if v == nil {
+			v280v2 = nil
+		} else {
+			v280v2 = make(map[bool]int, len(v))
+		} // reset map
+		var v280v3, v280v4 typMapMapBoolInt
+		v280v3 = typMapMapBoolInt(v280v1)
+		v280v4 = typMapMapBoolInt(v280v2)
+		bs280 = testMarshalErr(v280v3, h, t, "enc-map-v280-custom")
+		testUnmarshalErr(v280v4, bs280, h, t, "dec-map-v280-p-len")
+		testDeepEqualErr(v280v3, v280v4, t, "equal-map-v280-p-len")
+	}
+
+	for _, v := range []map[bool]int8{nil, {}, {true: 0}} {
+		// fmt.Printf(">>>> running mammoth map v281: %v\n", v)
+		var v281v1, v281v2 map[bool]int8
+		v281v1 = v
+		bs281 := testMarshalErr(v281v1, h, t, "enc-map-v281")
+		if v == nil {
+			v281v2 = nil
+		} else {
+			v281v2 = make(map[bool]int8, len(v))
+		} // reset map
+		testUnmarshalErr(v281v2, bs281, h, t, "dec-map-v281")
+		testDeepEqualErr(v281v1, v281v2, t, "equal-map-v281")
+		if v == nil {
+			v281v2 = nil
+		} else {
+			v281v2 = make(map[bool]int8, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v281v2), bs281, h, t, "dec-map-v281-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v281v1, v281v2, t, "equal-map-v281-noaddr")
+		if v == nil {
+			v281v2 = nil
+		} else {
+			v281v2 = make(map[bool]int8, len(v))
+		} // reset map
+		testUnmarshalErr(&v281v2, bs281, h, t, "dec-map-v281-p-len")
+		testDeepEqualErr(v281v1, v281v2, t, "equal-map-v281-p-len")
+		bs281 = testMarshalErr(&v281v1, h, t, "enc-map-v281-p")
+		v281v2 = nil
+		testUnmarshalErr(&v281v2, bs281, h, t, "dec-map-v281-p-nil")
+		testDeepEqualErr(v281v1, v281v2, t, "equal-map-v281-p-nil")
+		// ...
+		if v == nil {
+			v281v2 = nil
+		} else {
+			v281v2 = make(map[bool]int8, len(v))
+		} // reset map
+		var v281v3, v281v4 typMapMapBoolInt8
+		v281v3 = typMapMapBoolInt8(v281v1)
+		v281v4 = typMapMapBoolInt8(v281v2)
+		bs281 = testMarshalErr(v281v3, h, t, "enc-map-v281-custom")
+		testUnmarshalErr(v281v4, bs281, h, t, "dec-map-v281-p-len")
+		testDeepEqualErr(v281v3, v281v4, t, "equal-map-v281-p-len")
+	}
+
+	for _, v := range []map[bool]int16{nil, {}, {true: 0}} {
+		// fmt.Printf(">>>> running mammoth map v282: %v\n", v)
+		var v282v1, v282v2 map[bool]int16
+		v282v1 = v
+		bs282 := testMarshalErr(v282v1, h, t, "enc-map-v282")
+		if v == nil {
+			v282v2 = nil
+		} else {
+			v282v2 = make(map[bool]int16, len(v))
+		} // reset map
+		testUnmarshalErr(v282v2, bs282, h, t, "dec-map-v282")
+		testDeepEqualErr(v282v1, v282v2, t, "equal-map-v282")
+		if v == nil {
+			v282v2 = nil
+		} else {
+			v282v2 = make(map[bool]int16, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v282v2), bs282, h, t, "dec-map-v282-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v282v1, v282v2, t, "equal-map-v282-noaddr")
+		if v == nil {
+			v282v2 = nil
+		} else {
+			v282v2 = make(map[bool]int16, len(v))
+		} // reset map
+		testUnmarshalErr(&v282v2, bs282, h, t, "dec-map-v282-p-len")
+		testDeepEqualErr(v282v1, v282v2, t, "equal-map-v282-p-len")
+		bs282 = testMarshalErr(&v282v1, h, t, "enc-map-v282-p")
+		v282v2 = nil
+		testUnmarshalErr(&v282v2, bs282, h, t, "dec-map-v282-p-nil")
+		testDeepEqualErr(v282v1, v282v2, t, "equal-map-v282-p-nil")
+		// ...
+		if v == nil {
+			v282v2 = nil
+		} else {
+			v282v2 = make(map[bool]int16, len(v))
+		} // reset map
+		var v282v3, v282v4 typMapMapBoolInt16
+		v282v3 = typMapMapBoolInt16(v282v1)
+		v282v4 = typMapMapBoolInt16(v282v2)
+		bs282 = testMarshalErr(v282v3, h, t, "enc-map-v282-custom")
+		testUnmarshalErr(v282v4, bs282, h, t, "dec-map-v282-p-len")
+		testDeepEqualErr(v282v3, v282v4, t, "equal-map-v282-p-len")
+	}
+
+	for _, v := range []map[bool]int32{nil, {}, {true: 0}} {
+		// fmt.Printf(">>>> running mammoth map v283: %v\n", v)
+		var v283v1, v283v2 map[bool]int32
+		v283v1 = v
+		bs283 := testMarshalErr(v283v1, h, t, "enc-map-v283")
+		if v == nil {
+			v283v2 = nil
+		} else {
+			v283v2 = make(map[bool]int32, len(v))
+		} // reset map
+		testUnmarshalErr(v283v2, bs283, h, t, "dec-map-v283")
+		testDeepEqualErr(v283v1, v283v2, t, "equal-map-v283")
+		if v == nil {
+			v283v2 = nil
+		} else {
+			v283v2 = make(map[bool]int32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v283v2), bs283, h, t, "dec-map-v283-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v283v1, v283v2, t, "equal-map-v283-noaddr")
+		if v == nil {
+			v283v2 = nil
+		} else {
+			v283v2 = make(map[bool]int32, len(v))
+		} // reset map
+		testUnmarshalErr(&v283v2, bs283, h, t, "dec-map-v283-p-len")
+		testDeepEqualErr(v283v1, v283v2, t, "equal-map-v283-p-len")
+		bs283 = testMarshalErr(&v283v1, h, t, "enc-map-v283-p")
+		v283v2 = nil
+		testUnmarshalErr(&v283v2, bs283, h, t, "dec-map-v283-p-nil")
+		testDeepEqualErr(v283v1, v283v2, t, "equal-map-v283-p-nil")
+		// ...
+		if v == nil {
+			v283v2 = nil
+		} else {
+			v283v2 = make(map[bool]int32, len(v))
+		} // reset map
+		var v283v3, v283v4 typMapMapBoolInt32
+		v283v3 = typMapMapBoolInt32(v283v1)
+		v283v4 = typMapMapBoolInt32(v283v2)
+		bs283 = testMarshalErr(v283v3, h, t, "enc-map-v283-custom")
+		testUnmarshalErr(v283v4, bs283, h, t, "dec-map-v283-p-len")
+		testDeepEqualErr(v283v3, v283v4, t, "equal-map-v283-p-len")
+	}
+
+	for _, v := range []map[bool]int64{nil, {}, {true: 0}} {
+		// fmt.Printf(">>>> running mammoth map v284: %v\n", v)
+		var v284v1, v284v2 map[bool]int64
+		v284v1 = v
+		bs284 := testMarshalErr(v284v1, h, t, "enc-map-v284")
+		if v == nil {
+			v284v2 = nil
+		} else {
+			v284v2 = make(map[bool]int64, len(v))
+		} // reset map
+		testUnmarshalErr(v284v2, bs284, h, t, "dec-map-v284")
+		testDeepEqualErr(v284v1, v284v2, t, "equal-map-v284")
+		if v == nil {
+			v284v2 = nil
+		} else {
+			v284v2 = make(map[bool]int64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v284v2), bs284, h, t, "dec-map-v284-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v284v1, v284v2, t, "equal-map-v284-noaddr")
+		if v == nil {
+			v284v2 = nil
+		} else {
+			v284v2 = make(map[bool]int64, len(v))
+		} // reset map
+		testUnmarshalErr(&v284v2, bs284, h, t, "dec-map-v284-p-len")
+		testDeepEqualErr(v284v1, v284v2, t, "equal-map-v284-p-len")
+		bs284 = testMarshalErr(&v284v1, h, t, "enc-map-v284-p")
+		v284v2 = nil
+		testUnmarshalErr(&v284v2, bs284, h, t, "dec-map-v284-p-nil")
+		testDeepEqualErr(v284v1, v284v2, t, "equal-map-v284-p-nil")
+		// ...
+		if v == nil {
+			v284v2 = nil
+		} else {
+			v284v2 = make(map[bool]int64, len(v))
+		} // reset map
+		var v284v3, v284v4 typMapMapBoolInt64
+		v284v3 = typMapMapBoolInt64(v284v1)
+		v284v4 = typMapMapBoolInt64(v284v2)
+		bs284 = testMarshalErr(v284v3, h, t, "enc-map-v284-custom")
+		testUnmarshalErr(v284v4, bs284, h, t, "dec-map-v284-p-len")
+		testDeepEqualErr(v284v3, v284v4, t, "equal-map-v284-p-len")
+	}
+
+	for _, v := range []map[bool]float32{nil, {}, {true: 0}} {
+		// fmt.Printf(">>>> running mammoth map v285: %v\n", v)
+		var v285v1, v285v2 map[bool]float32
+		v285v1 = v
+		bs285 := testMarshalErr(v285v1, h, t, "enc-map-v285")
+		if v == nil {
+			v285v2 = nil
+		} else {
+			v285v2 = make(map[bool]float32, len(v))
+		} // reset map
+		testUnmarshalErr(v285v2, bs285, h, t, "dec-map-v285")
+		testDeepEqualErr(v285v1, v285v2, t, "equal-map-v285")
+		if v == nil {
+			v285v2 = nil
+		} else {
+			v285v2 = make(map[bool]float32, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v285v2), bs285, h, t, "dec-map-v285-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v285v1, v285v2, t, "equal-map-v285-noaddr")
+		if v == nil {
+			v285v2 = nil
+		} else {
+			v285v2 = make(map[bool]float32, len(v))
+		} // reset map
+		testUnmarshalErr(&v285v2, bs285, h, t, "dec-map-v285-p-len")
+		testDeepEqualErr(v285v1, v285v2, t, "equal-map-v285-p-len")
+		bs285 = testMarshalErr(&v285v1, h, t, "enc-map-v285-p")
+		v285v2 = nil
+		testUnmarshalErr(&v285v2, bs285, h, t, "dec-map-v285-p-nil")
+		testDeepEqualErr(v285v1, v285v2, t, "equal-map-v285-p-nil")
+		// ...
+		if v == nil {
+			v285v2 = nil
+		} else {
+			v285v2 = make(map[bool]float32, len(v))
+		} // reset map
+		var v285v3, v285v4 typMapMapBoolFloat32
+		v285v3 = typMapMapBoolFloat32(v285v1)
+		v285v4 = typMapMapBoolFloat32(v285v2)
+		bs285 = testMarshalErr(v285v3, h, t, "enc-map-v285-custom")
+		testUnmarshalErr(v285v4, bs285, h, t, "dec-map-v285-p-len")
+		testDeepEqualErr(v285v3, v285v4, t, "equal-map-v285-p-len")
+	}
+
+	for _, v := range []map[bool]float64{nil, {}, {true: 0}} {
+		// fmt.Printf(">>>> running mammoth map v286: %v\n", v)
+		var v286v1, v286v2 map[bool]float64
+		v286v1 = v
+		bs286 := testMarshalErr(v286v1, h, t, "enc-map-v286")
+		if v == nil {
+			v286v2 = nil
+		} else {
+			v286v2 = make(map[bool]float64, len(v))
+		} // reset map
+		testUnmarshalErr(v286v2, bs286, h, t, "dec-map-v286")
+		testDeepEqualErr(v286v1, v286v2, t, "equal-map-v286")
+		if v == nil {
+			v286v2 = nil
+		} else {
+			v286v2 = make(map[bool]float64, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v286v2), bs286, h, t, "dec-map-v286-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v286v1, v286v2, t, "equal-map-v286-noaddr")
+		if v == nil {
+			v286v2 = nil
+		} else {
+			v286v2 = make(map[bool]float64, len(v))
+		} // reset map
+		testUnmarshalErr(&v286v2, bs286, h, t, "dec-map-v286-p-len")
+		testDeepEqualErr(v286v1, v286v2, t, "equal-map-v286-p-len")
+		bs286 = testMarshalErr(&v286v1, h, t, "enc-map-v286-p")
+		v286v2 = nil
+		testUnmarshalErr(&v286v2, bs286, h, t, "dec-map-v286-p-nil")
+		testDeepEqualErr(v286v1, v286v2, t, "equal-map-v286-p-nil")
+		// ...
+		if v == nil {
+			v286v2 = nil
+		} else {
+			v286v2 = make(map[bool]float64, len(v))
+		} // reset map
+		var v286v3, v286v4 typMapMapBoolFloat64
+		v286v3 = typMapMapBoolFloat64(v286v1)
+		v286v4 = typMapMapBoolFloat64(v286v2)
+		bs286 = testMarshalErr(v286v3, h, t, "enc-map-v286-custom")
+		testUnmarshalErr(v286v4, bs286, h, t, "dec-map-v286-p-len")
+		testDeepEqualErr(v286v3, v286v4, t, "equal-map-v286-p-len")
+	}
+
+	for _, v := range []map[bool]bool{nil, {}, {true: false}} {
+		// fmt.Printf(">>>> running mammoth map v287: %v\n", v)
+		var v287v1, v287v2 map[bool]bool
+		v287v1 = v
+		bs287 := testMarshalErr(v287v1, h, t, "enc-map-v287")
+		if v == nil {
+			v287v2 = nil
+		} else {
+			v287v2 = make(map[bool]bool, len(v))
+		} // reset map
+		testUnmarshalErr(v287v2, bs287, h, t, "dec-map-v287")
+		testDeepEqualErr(v287v1, v287v2, t, "equal-map-v287")
+		if v == nil {
+			v287v2 = nil
+		} else {
+			v287v2 = make(map[bool]bool, len(v))
+		} // reset map
+		testUnmarshalErr(reflect.ValueOf(v287v2), bs287, h, t, "dec-map-v287-noaddr") // decode into non-addressable map value
+		testDeepEqualErr(v287v1, v287v2, t, "equal-map-v287-noaddr")
+		if v == nil {
+			v287v2 = nil
+		} else {
+			v287v2 = make(map[bool]bool, len(v))
+		} // reset map
+		testUnmarshalErr(&v287v2, bs287, h, t, "dec-map-v287-p-len")
+		testDeepEqualErr(v287v1, v287v2, t, "equal-map-v287-p-len")
+		bs287 = testMarshalErr(&v287v1, h, t, "enc-map-v287-p")
+		v287v2 = nil
+		testUnmarshalErr(&v287v2, bs287, h, t, "dec-map-v287-p-nil")
+		testDeepEqualErr(v287v1, v287v2, t, "equal-map-v287-p-nil")
+		// ...
+		if v == nil {
+			v287v2 = nil
+		} else {
+			v287v2 = make(map[bool]bool, len(v))
+		} // reset map
+		var v287v3, v287v4 typMapMapBoolBool
+		v287v3 = typMapMapBoolBool(v287v1)
+		v287v4 = typMapMapBoolBool(v287v2)
+		bs287 = testMarshalErr(v287v3, h, t, "enc-map-v287-custom")
+		testUnmarshalErr(v287v4, bs287, h, t, "dec-map-v287-p-len")
+		testDeepEqualErr(v287v3, v287v4, t, "equal-map-v287-p-len")
+	}
+
+}
+
+func doTestMammothMapsAndSlices(t *testing.T, h Handle) {
+	doTestMammothSlices(t, h)
+	doTestMammothMaps(t, h)
+}
diff --git a/vendor/github.com/ugorji/go/codec/msgpack.go b/vendor/github.com/ugorji/go/codec/msgpack.go
index 3c58daf3f..ec9cb0fb4 100644
--- a/vendor/github.com/ugorji/go/codec/msgpack.go
+++ b/vendor/github.com/ugorji/go/codec/msgpack.go
@@ -15,8 +15,8 @@ For compatibility with behaviour of msgpack-c reference implementation:
   - Go intX (<0)
        IS ENCODED AS
     msgpack -ve fixnum, signed
-
 */
+
 package codec
 
 import (
@@ -25,6 +25,7 @@ import (
 	"math"
 	"net/rpc"
 	"reflect"
+	"time"
 )
 
 const (
@@ -78,6 +79,9 @@ const (
 	mpNegFixNumMax = 0xff
 )
 
+var mpTimeExtTag int8 = -1
+var mpTimeExtTagU = uint8(mpTimeExtTag)
+
 // MsgpackSpecRpcMultiArgs is a special type which signifies to the MsgpackSpecRpcCodec
 // that the backend RPC service takes multiple arguments, which have been arranged
 // in sequence in the slice.
@@ -104,7 +108,8 @@ var (
 
 type msgpackEncDriver struct {
 	noBuiltInTypes
-	encNoSeparator
+	encDriverNoopContainerWriter
+	// encNoSeparator
 	e *Encoder
 	w encWriter
 	h *MsgpackHandle
@@ -116,10 +121,26 @@ func (e *msgpackEncDriver) EncodeNil() {
 }
 
 func (e *msgpackEncDriver) EncodeInt(i int64) {
-	if i >= 0 {
-		e.EncodeUint(uint64(i))
+	// if i >= 0 {
+	// 	e.EncodeUint(uint64(i))
+	// } else if false &&
+	if i > math.MaxInt8 {
+		if i <= math.MaxInt16 {
+			e.w.writen1(mpInt16)
+			bigenHelper{e.x[:2], e.w}.writeUint16(uint16(i))
+		} else if i <= math.MaxInt32 {
+			e.w.writen1(mpInt32)
+			bigenHelper{e.x[:4], e.w}.writeUint32(uint32(i))
+		} else {
+			e.w.writen1(mpInt64)
+			bigenHelper{e.x[:8], e.w}.writeUint64(uint64(i))
+		}
 	} else if i >= -32 {
-		e.w.writen1(byte(i))
+		if e.h.NoFixedNum {
+			e.w.writen2(mpInt8, byte(i))
+		} else {
+			e.w.writen1(byte(i))
+		}
 	} else if i >= math.MinInt8 {
 		e.w.writen2(mpInt8, byte(i))
 	} else if i >= math.MinInt16 {
@@ -136,7 +157,11 @@ func (e *msgpackEncDriver) EncodeInt(i int64) {
 
 func (e *msgpackEncDriver) EncodeUint(i uint64) {
 	if i <= math.MaxInt8 {
-		e.w.writen1(byte(i))
+		if e.h.NoFixedNum {
+			e.w.writen2(mpUint8, byte(i))
+		} else {
+			e.w.writen1(byte(i))
+		}
 	} else if i <= math.MaxUint8 {
 		e.w.writen2(mpUint8, byte(i))
 	} else if i <= math.MaxUint16 {
@@ -169,6 +194,39 @@ func (e *msgpackEncDriver) EncodeFloat64(f float64) {
 	bigenHelper{e.x[:8], e.w}.writeUint64(math.Float64bits(f))
 }
 
+func (e *msgpackEncDriver) EncodeTime(t time.Time) {
+	if t.IsZero() {
+		e.EncodeNil()
+		return
+	}
+	t = t.UTC()
+	sec, nsec := t.Unix(), uint64(t.Nanosecond())
+	var data64 uint64
+	var l = 4
+	if sec >= 0 && sec>>34 == 0 {
+		data64 = (nsec << 34) | uint64(sec)
+		if data64&0xffffffff00000000 != 0 {
+			l = 8
+		}
+	} else {
+		l = 12
+	}
+	if e.h.WriteExt {
+		e.encodeExtPreamble(mpTimeExtTagU, l)
+	} else {
+		e.writeContainerLen(msgpackContainerStr, l)
+	}
+	switch l {
+	case 4:
+		bigenHelper{e.x[:4], e.w}.writeUint32(uint32(data64))
+	case 8:
+		bigenHelper{e.x[:8], e.w}.writeUint64(data64)
+	case 12:
+		bigenHelper{e.x[:4], e.w}.writeUint32(uint32(nsec))
+		bigenHelper{e.x[:8], e.w}.writeUint64(uint64(sec))
+	}
+}
+
 func (e *msgpackEncDriver) EncodeExt(v interface{}, xtag uint64, ext Ext, _ *Encoder) {
 	bs := ext.WriteExt(v)
 	if bs == nil {
@@ -179,7 +237,7 @@ func (e *msgpackEncDriver) EncodeExt(v interface{}, xtag uint64, ext Ext, _ *Enc
 		e.encodeExtPreamble(uint8(xtag), len(bs))
 		e.w.writeb(bs)
 	} else {
-		e.EncodeStringBytes(c_RAW, bs)
+		e.EncodeStringBytes(cRAW, bs)
 	}
 }
 
@@ -213,36 +271,42 @@ func (e *msgpackEncDriver) encodeExtPreamble(xtag byte, l int) {
 	}
 }
 
-func (e *msgpackEncDriver) EncodeArrayStart(length int) {
+func (e *msgpackEncDriver) WriteArrayStart(length int) {
 	e.writeContainerLen(msgpackContainerList, length)
 }
 
-func (e *msgpackEncDriver) EncodeMapStart(length int) {
+func (e *msgpackEncDriver) WriteMapStart(length int) {
 	e.writeContainerLen(msgpackContainerMap, length)
 }
 
 func (e *msgpackEncDriver) EncodeString(c charEncoding, s string) {
-	if c == c_RAW && e.h.WriteExt {
-		e.writeContainerLen(msgpackContainerBin, len(s))
+	slen := len(s)
+	if c == cRAW && e.h.WriteExt {
+		e.writeContainerLen(msgpackContainerBin, slen)
 	} else {
-		e.writeContainerLen(msgpackContainerStr, len(s))
+		e.writeContainerLen(msgpackContainerStr, slen)
 	}
-	if len(s) > 0 {
+	if slen > 0 {
 		e.w.writestr(s)
 	}
 }
 
 func (e *msgpackEncDriver) EncodeSymbol(v string) {
-	e.EncodeString(c_UTF8, v)
+	e.EncodeString(cUTF8, v)
 }
 
 func (e *msgpackEncDriver) EncodeStringBytes(c charEncoding, bs []byte) {
-	if c == c_RAW && e.h.WriteExt {
-		e.writeContainerLen(msgpackContainerBin, len(bs))
-	} else {
-		e.writeContainerLen(msgpackContainerStr, len(bs))
+	if bs == nil {
+		e.EncodeNil()
+		return
 	}
-	if len(bs) > 0 {
+	slen := len(bs)
+	if c == cRAW && e.h.WriteExt {
+		e.writeContainerLen(msgpackContainerBin, slen)
+	} else {
+		e.writeContainerLen(msgpackContainerStr, slen)
+	}
+	if slen > 0 {
 		e.w.writeb(bs)
 	}
 }
@@ -272,8 +336,9 @@ type msgpackDecDriver struct {
 	bdRead bool
 	br     bool // bytes reader
 	noBuiltInTypes
-	noStreamingCodec
-	decNoSeparator
+	// noStreamingCodec
+	// decNoSeparator
+	decDriverNoopContainerReader
 }
 
 // Note: This returns either a primitive (int, bool, etc) for non-containers,
@@ -286,7 +351,7 @@ func (d *msgpackDecDriver) DecodeNaked() {
 		d.readNextBd()
 	}
 	bd := d.bd
-	n := &d.d.n
+	n := d.d.n
 	var decodeFurther bool
 
 	switch bd {
@@ -364,7 +429,12 @@ func (d *msgpackDecDriver) DecodeNaked() {
 			n.v = valueTypeExt
 			clen := d.readExtLen()
 			n.u = uint64(d.r.readn1())
-			n.l = d.r.readx(clen)
+			if n.u == uint64(mpTimeExtTagU) {
+				n.v = valueTypeTime
+				n.t = d.decodeTime(clen)
+			} else {
+				n.l = d.r.readx(clen)
+			}
 		default:
 			d.d.errorf("Nil-Deciphered DecodeValue: %s: hex: %x, dec: %d", msgBadDesc, bd, bd)
 		}
@@ -489,7 +559,7 @@ func (d *msgpackDecDriver) DecodeUint(bitsize uint8) (ui uint64) {
 }
 
 // float can either be decoded from msgpack type: float, double or intX
-func (d *msgpackDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) {
+func (d *msgpackDecDriver) DecodeFloat64() (f float64) {
 	if !d.bdRead {
 		d.readNextBd()
 	}
@@ -500,10 +570,6 @@ func (d *msgpackDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) {
 	} else {
 		f = float64(d.DecodeInt(0))
 	}
-	if chkOverflow32 && chkOvf.Float32(f) {
-		d.d.errorf("msgpack: float32 overflow: %v", f)
-		return
-	}
 	d.bdRead = false
 	return
 }
@@ -529,12 +595,46 @@ func (d *msgpackDecDriver) DecodeBytes(bs []byte, zerocopy bool) (bsOut []byte)
 	if !d.bdRead {
 		d.readNextBd()
 	}
+
+	// check if an "array" of uint8's (see ContainerType for how to infer if an array)
+	bd := d.bd
+	// DecodeBytes could be from: bin str fixstr fixarray array ...
 	var clen int
-	if bd := d.bd; bd == mpBin8 || bd == mpBin16 || bd == mpBin32 {
-		clen = d.readContainerLen(msgpackContainerBin)
-	} else {
+	vt := d.ContainerType()
+	switch vt {
+	case valueTypeBytes:
+		// valueTypeBytes may be a mpBin or an mpStr container
+		if bd == mpBin8 || bd == mpBin16 || bd == mpBin32 {
+			clen = d.readContainerLen(msgpackContainerBin)
+		} else {
+			clen = d.readContainerLen(msgpackContainerStr)
+		}
+	case valueTypeString:
 		clen = d.readContainerLen(msgpackContainerStr)
+	case valueTypeArray:
+		bsOut, _ = fastpathTV.DecSliceUint8V(bs, true, d.d)
+		return
+		// clen = d.readContainerLen(msgpackContainerList)
+		// // ensure everything after is one byte each
+		// for i := 0; i < clen; i++ {
+		// 	d.readNextBd()
+		// 	if d.bd == mpNil {
+		// 		bs = append(bs, 0)
+		// 	} else if d.bd == mpUint8 {
+		// 		bs = append(bs, d.r.readn1())
+		// 	} else {
+		// 		d.d.errorf("cannot read non-byte into a byte array")
+		// 		return
+		// 	}
+		// }
+		// d.bdRead = false
+		// return bs
+	default:
+		d.d.errorf("invalid container type: expecting bin|str|array, got: 0x%x", uint8(vt))
+		return
 	}
+
+	// these are (bin|str)(8|16|32)
 	// println("DecodeBytes: clen: ", clen)
 	d.bdRead = false
 	// bytes may be nil, so handle it. if nil, clen=-1.
@@ -589,9 +689,10 @@ func (d *msgpackDecDriver) ContainerType() (vt valueType) {
 		return valueTypeArray
 	} else if bd == mpMap16 || bd == mpMap32 || (bd >= mpFixMapMin && bd <= mpFixMapMax) {
 		return valueTypeMap
-	} else {
-		// d.d.errorf("isContainerType: unsupported parameter: %v", vt)
 	}
+	// else {
+	// d.d.errorf("isContainerType: unsupported parameter: %v", vt)
+	// }
 	return valueTypeUnset
 }
 
@@ -601,7 +702,7 @@ func (d *msgpackDecDriver) TryDecodeAsNil() (v bool) {
 	}
 	if d.bd == mpNil {
 		d.bdRead = false
-		v = true
+		return true
 	}
 	return
 }
@@ -667,6 +768,57 @@ func (d *msgpackDecDriver) readExtLen() (clen int) {
 	return
 }
 
+func (d *msgpackDecDriver) DecodeTime() (t time.Time) {
+	// decode time from string bytes or ext
+	if !d.bdRead {
+		d.readNextBd()
+	}
+	if d.bd == mpNil {
+		d.bdRead = false
+		return
+	}
+	var clen int
+	switch d.ContainerType() {
+	case valueTypeBytes, valueTypeString:
+		clen = d.readContainerLen(msgpackContainerStr)
+	default:
+		// expect to see mpFixExt4,-1 OR mpFixExt8,-1 OR mpExt8,12,-1
+		d.bdRead = false
+		b2 := d.r.readn1()
+		if d.bd == mpFixExt4 && b2 == mpTimeExtTagU {
+			clen = 4
+		} else if d.bd == mpFixExt8 && b2 == mpTimeExtTagU {
+			clen = 8
+		} else if d.bd == mpExt8 && b2 == 12 && d.r.readn1() == mpTimeExtTagU {
+			clen = 12
+		} else {
+			d.d.errorf("invalid sequence of bytes for decoding time as an extension: got 0x%x, 0x%x", d.bd, b2)
+			return
+		}
+	}
+	return d.decodeTime(clen)
+}
+
+func (d *msgpackDecDriver) decodeTime(clen int) (t time.Time) {
+	// bs = d.r.readx(clen)
+	d.bdRead = false
+	switch clen {
+	case 4:
+		t = time.Unix(int64(bigen.Uint32(d.r.readx(4))), 0).UTC()
+	case 8:
+		tv := bigen.Uint64(d.r.readx(8))
+		t = time.Unix(int64(tv&0x00000003ffffffff), int64(tv>>34)).UTC()
+	case 12:
+		nsec := bigen.Uint32(d.r.readx(4))
+		sec := bigen.Uint64(d.r.readx(8))
+		t = time.Unix(int64(sec), int64(nsec)).UTC()
+	default:
+		d.d.errorf("invalid length of bytes for decoding time - expecting 4 or 8 or 12, got %d", clen)
+		return
+	}
+	return
+}
+
 func (d *msgpackDecDriver) DecodeExt(rv interface{}, xtag uint64, ext Ext) (realxtag uint64) {
 	if xtag > 0xff {
 		d.d.errorf("decodeExt: tag must be <= 0xff; got: %v", xtag)
@@ -716,6 +868,9 @@ type MsgpackHandle struct {
 	// RawToString controls how raw bytes are decoded into a nil interface{}.
 	RawToString bool
 
+	// NoFixedNum says to output all signed integers as 2-bytes, never as 1-byte fixednum.
+	NoFixedNum bool
+
 	// WriteExt flag supports encoding configured extensions with extension tags.
 	// It also controls whether other elements of the new spec are encoded (ie Str8).
 	//
@@ -728,8 +883,13 @@ type MsgpackHandle struct {
 	// a []byte or string based on the setting of RawToString.
 	WriteExt bool
 	binaryEncodingType
+	noElemSeparators
 }
 
+// Name returns the name of the handle: msgpack
+func (h *MsgpackHandle) Name() string { return "msgpack" }
+
+// SetBytesExt sets an extension
 func (h *MsgpackHandle) SetBytesExt(rt reflect.Type, tag uint64, ext BytesExt) (err error) {
 	return h.SetExt(rt, tag, &setExtWrapper{b: ext})
 }
@@ -769,7 +929,7 @@ func (c *msgpackSpecRpcCodec) WriteRequest(r *rpc.Request, body interface{}) err
 		bodyArr = []interface{}{body}
 	}
 	r2 := []interface{}{0, uint32(r.Seq), r.ServiceMethod, bodyArr}
-	return c.write(r2, nil, false, true)
+	return c.write(r2, nil, false)
 }
 
 func (c *msgpackSpecRpcCodec) WriteResponse(r *rpc.Response, body interface{}) error {
@@ -781,7 +941,7 @@ func (c *msgpackSpecRpcCodec) WriteResponse(r *rpc.Response, body interface{}) e
 		body = nil
 	}
 	r2 := []interface{}{1, uint32(r.Seq), moe, body}
-	return c.write(r2, nil, false, true)
+	return c.write(r2, nil, false)
 }
 
 func (c *msgpackSpecRpcCodec) ReadResponseHeader(r *rpc.Response) error {
@@ -801,7 +961,6 @@ func (c *msgpackSpecRpcCodec) ReadRequestBody(body interface{}) error {
 }
 
 func (c *msgpackSpecRpcCodec) parseCustomHeader(expectTypeByte byte, msgid *uint64, methodOrError *string) (err error) {
-
 	if c.isClosed() {
 		return io.EOF
 	}
@@ -815,28 +974,33 @@ func (c *msgpackSpecRpcCodec) parseCustomHeader(expectTypeByte byte, msgid *uint
 	// 	err = fmt.Errorf("Unexpected value for array descriptor: Expecting %v. Received %v", fia, bs1)
 	// 	return
 	// }
-	var b byte
-	b, err = c.br.ReadByte()
-	if err != nil {
-		return
-	}
-	if b != fia {
-		err = fmt.Errorf("Unexpected value for array descriptor: Expecting %v. Received %v", fia, b)
-		return
+	var ba [1]byte
+	var n int
+	for {
+		n, err = c.r.Read(ba[:])
+		if err != nil {
+			return
+		}
+		if n == 1 {
+			break
+		}
 	}
 
-	if err = c.read(&b); err != nil {
-		return
-	}
-	if b != expectTypeByte {
-		err = fmt.Errorf("Unexpected byte descriptor in header. Expecting %v. Received %v", expectTypeByte, b)
-		return
-	}
-	if err = c.read(msgid); err != nil {
-		return
-	}
-	if err = c.read(methodOrError); err != nil {
-		return
+	var b = ba[0]
+	if b != fia {
+		err = fmt.Errorf("Unexpected value for array descriptor: Expecting %v. Received %v", fia, b)
+	} else {
+		err = c.read(&b)
+		if err == nil {
+			if b != expectTypeByte {
+				err = fmt.Errorf("Unexpected byte descriptor in header. Expecting %v. Received %v", expectTypeByte, b)
+			} else {
+				err = c.read(msgid)
+				if err == nil {
+					err = c.read(methodOrError)
+				}
+			}
+		}
 	}
 	return
 }
@@ -849,7 +1013,8 @@ type msgpackSpecRpc struct{}
 
 // MsgpackSpecRpc implements Rpc using the communication protocol defined in
 // the msgpack spec at https://github.com/msgpack-rpc/msgpack-rpc/blob/master/spec.md .
-// Its methods (ServerCodec and ClientCodec) return values that implement RpcCodecBuffered.
+//
+// See GoRpc documentation, for information on buffering for better performance.
 var MsgpackSpecRpc msgpackSpecRpc
 
 func (x msgpackSpecRpc) ServerCodec(conn io.ReadWriteCloser, h Handle) rpc.ServerCodec {
diff --git a/vendor/github.com/ugorji/go/codec/noop.go b/vendor/github.com/ugorji/go/codec/noop.go
index a7825156d..015af581a 100644
--- a/vendor/github.com/ugorji/go/codec/noop.go
+++ b/vendor/github.com/ugorji/go/codec/noop.go
@@ -1,6 +1,8 @@
 // Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
 // Use of this source code is governed by a MIT license found in the LICENSE file.
 
+// +build ignore
+
 package codec
 
 import (
diff --git a/vendor/github.com/ugorji/go/codec/rpc.go b/vendor/github.com/ugorji/go/codec/rpc.go
index 8062bed31..ee4a9d2e7 100644
--- a/vendor/github.com/ugorji/go/codec/rpc.go
+++ b/vendor/github.com/ugorji/go/codec/rpc.go
@@ -5,123 +5,148 @@ package codec
 
 import (
 	"bufio"
+	"errors"
 	"io"
 	"net/rpc"
 	"sync"
 )
 
-// rpcEncodeTerminator allows a handler specify a []byte terminator to send after each Encode.
-//
-// Some codecs like json need to put a space after each encoded value, to serve as a
-// delimiter for things like numbers (else json codec will continue reading till EOF).
-type rpcEncodeTerminator interface {
-	rpcEncodeTerminate() []byte
-}
-
 // Rpc provides a rpc Server or Client Codec for rpc communication.
 type Rpc interface {
 	ServerCodec(conn io.ReadWriteCloser, h Handle) rpc.ServerCodec
 	ClientCodec(conn io.ReadWriteCloser, h Handle) rpc.ClientCodec
 }
 
-// RpcCodecBuffered allows access to the underlying bufio.Reader/Writer
-// used by the rpc connection. It accommodates use-cases where the connection
-// should be used by rpc and non-rpc functions, e.g. streaming a file after
-// sending an rpc response.
-type RpcCodecBuffered interface {
-	BufferedReader() *bufio.Reader
-	BufferedWriter() *bufio.Writer
+type RPCOptions struct {
+	// RPCNoBuffer configures whether we attempt to buffer reads and writes during RPC calls.
+	//
+	// Set RPCNoBuffer=true to turn buffering off.
+	// Buffering can still be done if buffered connections are passed in, or
+	// buffering is configured on the handle.
+	RPCNoBuffer bool
 }
 
-// -------------------------------------
-
 // rpcCodec defines the struct members and common methods.
 type rpcCodec struct {
-	rwc io.ReadWriteCloser
+	c io.Closer
+	r io.Reader
+	w io.Writer
+	f ioFlusher
+
 	dec *Decoder
 	enc *Encoder
-	bw  *bufio.Writer
-	br  *bufio.Reader
-	mu  sync.Mutex
-	h   Handle
+	// bw  *bufio.Writer
+	// br  *bufio.Reader
+	mu sync.Mutex
+	h  Handle
 
-	cls   bool
-	clsmu sync.RWMutex
+	cls    bool
+	clsmu  sync.RWMutex
+	clsErr error
 }
 
 func newRPCCodec(conn io.ReadWriteCloser, h Handle) rpcCodec {
-	bw := bufio.NewWriter(conn)
-	br := bufio.NewReader(conn)
+	// return newRPCCodec2(bufio.NewReader(conn), bufio.NewWriter(conn), conn, h)
+	return newRPCCodec2(conn, conn, conn, h)
+}
+
+func newRPCCodec2(r io.Reader, w io.Writer, c io.Closer, h Handle) rpcCodec {
+	// defensive: ensure that jsonH has TermWhitespace turned on.
+	if jsonH, ok := h.(*JsonHandle); ok && !jsonH.TermWhitespace {
+		panic(errors.New("rpc requires a JsonHandle with TermWhitespace set to true"))
+	}
+	// always ensure that we use a flusher, and always flush what was written to the connection.
+	// we lose nothing by using a buffered writer internally.
+	f, ok := w.(ioFlusher)
+	bh := h.getBasicHandle()
+	if !bh.RPCNoBuffer {
+		if bh.WriterBufferSize <= 0 {
+			if !ok {
+				bw := bufio.NewWriter(w)
+				f, w = bw, bw
+			}
+		}
+		if bh.ReaderBufferSize <= 0 {
+			if _, ok = w.(ioPeeker); !ok {
+				if _, ok = w.(ioBuffered); !ok {
+					br := bufio.NewReader(r)
+					r = br
+				}
+			}
+		}
+	}
 	return rpcCodec{
-		rwc: conn,
-		bw:  bw,
-		br:  br,
-		enc: NewEncoder(bw, h),
-		dec: NewDecoder(br, h),
+		c:   c,
+		w:   w,
+		r:   r,
+		f:   f,
 		h:   h,
+		enc: NewEncoder(w, h),
+		dec: NewDecoder(r, h),
 	}
 }
 
-func (c *rpcCodec) BufferedReader() *bufio.Reader {
-	return c.br
-}
-
-func (c *rpcCodec) BufferedWriter() *bufio.Writer {
-	return c.bw
-}
-
-func (c *rpcCodec) write(obj1, obj2 interface{}, writeObj2, doFlush bool) (err error) {
+func (c *rpcCodec) write(obj1, obj2 interface{}, writeObj2 bool) (err error) {
 	if c.isClosed() {
-		return io.EOF
+		return c.clsErr
 	}
-	if err = c.enc.Encode(obj1); err != nil {
-		return
-	}
-	t, tOk := c.h.(rpcEncodeTerminator)
-	if tOk {
-		c.bw.Write(t.rpcEncodeTerminate())
-	}
-	if writeObj2 {
-		if err = c.enc.Encode(obj2); err != nil {
-			return
+	err = c.enc.Encode(obj1)
+	if err == nil {
+		if writeObj2 {
+			err = c.enc.Encode(obj2)
 		}
-		if tOk {
-			c.bw.Write(t.rpcEncodeTerminate())
+		if err == nil && c.f != nil {
+			err = c.f.Flush()
 		}
 	}
-	if doFlush {
-		return c.bw.Flush()
-	}
 	return
 }
 
+func (c *rpcCodec) swallow(err *error) {
+	defer panicToErr(c.dec, err)
+	c.dec.swallow()
+}
+
 func (c *rpcCodec) read(obj interface{}) (err error) {
 	if c.isClosed() {
-		return io.EOF
+		return c.clsErr
 	}
-	//If nil is passed in, we should still attempt to read content to nowhere.
+	//If nil is passed in, we should read and discard
 	if obj == nil {
-		var obj2 interface{}
-		return c.dec.Decode(&obj2)
+		// var obj2 interface{}
+		// return c.dec.Decode(&obj2)
+		c.swallow(&err)
+		return
 	}
 	return c.dec.Decode(obj)
 }
 
-func (c *rpcCodec) isClosed() bool {
-	c.clsmu.RLock()
-	x := c.cls
-	c.clsmu.RUnlock()
-	return x
+func (c *rpcCodec) isClosed() (b bool) {
+	if c.c != nil {
+		c.clsmu.RLock()
+		b = c.cls
+		c.clsmu.RUnlock()
+	}
+	return
 }
 
 func (c *rpcCodec) Close() error {
-	if c.isClosed() {
-		return io.EOF
+	if c.c == nil || c.isClosed() {
+		return c.clsErr
 	}
 	c.clsmu.Lock()
 	c.cls = true
+	var fErr error
+	if c.f != nil {
+		fErr = c.f.Flush()
+	}
+	_ = fErr
+	c.clsErr = c.c.Close()
+	if c.clsErr == nil && fErr != nil {
+		c.clsErr = fErr
+	}
 	c.clsmu.Unlock()
-	return c.rwc.Close()
+	return c.clsErr
 }
 
 func (c *rpcCodec) ReadResponseBody(body interface{}) error {
@@ -138,13 +163,13 @@ func (c *goRpcCodec) WriteRequest(r *rpc.Request, body interface{}) error {
 	// Must protect for concurrent access as per API
 	c.mu.Lock()
 	defer c.mu.Unlock()
-	return c.write(r, body, true, true)
+	return c.write(r, body, true)
 }
 
 func (c *goRpcCodec) WriteResponse(r *rpc.Response, body interface{}) error {
 	c.mu.Lock()
 	defer c.mu.Unlock()
-	return c.write(r, body, true, true)
+	return c.write(r, body, true)
 }
 
 func (c *goRpcCodec) ReadResponseHeader(r *rpc.Response) error {
@@ -166,7 +191,36 @@ func (c *goRpcCodec) ReadRequestBody(body interface{}) error {
 type goRpc struct{}
 
 // GoRpc implements Rpc using the communication protocol defined in net/rpc package.
-// Its methods (ServerCodec and ClientCodec) return values that implement RpcCodecBuffered.
+//
+// Note: network connection (from net.Dial, of type io.ReadWriteCloser) is not buffered.
+//
+// For performance, you should configure WriterBufferSize and ReaderBufferSize on the handle.
+// This ensures we use an adequate buffer during reading and writing.
+// If not configured, we will internally initialize and use a buffer during reads and writes.
+// This can be turned off via the RPCNoBuffer option on the Handle.
+//   var handle codec.JsonHandle
+//   handle.RPCNoBuffer = true // turns off attempt by rpc module to initialize a buffer
+//
+// Example 1: one way of configuring buffering explicitly:
+//   var handle codec.JsonHandle // codec handle
+//   handle.ReaderBufferSize = 1024
+//   handle.WriterBufferSize = 1024
+//   var conn io.ReadWriteCloser // connection got from a socket
+//   var serverCodec = GoRpc.ServerCodec(conn, handle)
+//   var clientCodec = GoRpc.ClientCodec(conn, handle)
+//
+// Example 2: you can also explicitly create a buffered connection yourself,
+//            and not worry about configuring the buffer sizes in the Handle.
+//   var handle codec.Handle     // codec handle
+//   var conn io.ReadWriteCloser // connection got from a socket
+//   var bufconn = struct {      // bufconn here is a buffered io.ReadWriteCloser
+//       io.Closer
+//       *bufio.Reader
+//       *bufio.Writer
+//   }{conn, bufio.NewReader(conn), bufio.NewWriter(conn)}
+//   var serverCodec = GoRpc.ServerCodec(bufconn, handle)
+//   var clientCodec = GoRpc.ClientCodec(bufconn, handle)
+//
 var GoRpc goRpc
 
 func (x goRpc) ServerCodec(conn io.ReadWriteCloser, h Handle) rpc.ServerCodec {
@@ -176,5 +230,3 @@ func (x goRpc) ServerCodec(conn io.ReadWriteCloser, h Handle) rpc.ServerCodec {
 func (x goRpc) ClientCodec(conn io.ReadWriteCloser, h Handle) rpc.ClientCodec {
 	return &goRpcCodec{newRPCCodec(conn, h)}
 }
-
-var _ RpcCodecBuffered = (*rpcCodec)(nil) // ensure *rpcCodec implements RpcCodecBuffered
diff --git a/vendor/github.com/ugorji/go/codec/shared_test.go b/vendor/github.com/ugorji/go/codec/shared_test.go
index 27b621d19..0a40c609b 100644
--- a/vendor/github.com/ugorji/go/codec/shared_test.go
+++ b/vendor/github.com/ugorji/go/codec/shared_test.go
@@ -43,7 +43,12 @@ package codec
 import (
 	"bytes"
 	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
 	"sync"
+	"testing"
 )
 
 // DO NOT REMOVE - replacement line for go-codec-bench import declaration tag //
@@ -54,8 +59,24 @@ type testHED struct {
 	D *Decoder
 }
 
+type ioReaderWrapper struct {
+	r io.Reader
+}
+
+func (x ioReaderWrapper) Read(p []byte) (n int, err error) {
+	return x.r.Read(p)
+}
+
+type ioWriterWrapper struct {
+	w io.Writer
+}
+
+func (x ioWriterWrapper) Write(p []byte) (n int, err error) {
+	return x.w.Write(p)
+}
+
 var (
-	testNoopH    = NoopHandle(8)
+	// testNoopH    = NoopHandle(8)
 	testMsgpackH = &MsgpackHandle{}
 	testBincH    = &BincHandle{}
 	testSimpleH  = &SimpleHandle{}
@@ -73,22 +94,32 @@ var (
 
 // flag variables used by tests (and bench)
 var (
-	testVerbose        bool
-	testInitDebug      bool
-	testUseIoEncDec    bool
-	testStructToArray  bool
-	testCanonical      bool
-	testUseReset       bool
-	testWriteNoSymbols bool
-	testSkipIntf       bool
-	testInternStr      bool
-	testUseMust        bool
-	testCheckCircRef   bool
-	testJsonIndent     int
-	testMaxInitLen     int
+	testDepth int
 
-	testJsonHTMLCharsAsIs bool
-	testJsonPreferFloat   bool
+	testVerbose       bool
+	testInitDebug     bool
+	testStructToArray bool
+	testCanonical     bool
+	testUseReset      bool
+	testSkipIntf      bool
+	testInternStr     bool
+	testUseMust       bool
+	testCheckCircRef  bool
+
+	testUseIoEncDec  int
+	testUseIoWrapper bool
+
+	testMaxInitLen int
+
+	testNumRepeatString int
+
+	testRpcBufsize int
+)
+
+// variables that are not flags, but which can configure the handles
+var (
+	testEncodeOptions EncodeOptions
+	testDecodeOptions DecodeOptions
 )
 
 // flag variables used by bench
@@ -104,9 +135,11 @@ var (
 )
 
 func init() {
+	log.SetOutput(ioutil.Discard) // don't allow things log to standard out/err
 	testHEDs = make([]testHED, 0, 32)
 	testHandles = append(testHandles,
-		testNoopH, testMsgpackH, testBincH, testSimpleH,
+		// testNoopH,
+		testMsgpackH, testBincH, testSimpleH,
 		testCborH, testJsonH)
 	testInitFlags()
 	benchInitFlags()
@@ -114,21 +147,20 @@ func init() {
 
 func testInitFlags() {
 	// delete(testDecOpts.ExtFuncs, timeTyp)
-	flag.BoolVar(&testVerbose, "tv", false, "Test Verbose")
+	flag.IntVar(&testDepth, "tsd", 0, "Test Struc Depth")
+	flag.BoolVar(&testVerbose, "tv", false, "Test Verbose (no longer used - here for compatibility)")
 	flag.BoolVar(&testInitDebug, "tg", false, "Test Init Debug")
-	flag.BoolVar(&testUseIoEncDec, "ti", false, "Use IO Reader/Writer for Marshal/Unmarshal")
+	flag.IntVar(&testUseIoEncDec, "ti", -1, "Use IO Reader/Writer for Marshal/Unmarshal ie >= 0")
+	flag.BoolVar(&testUseIoWrapper, "tiw", false, "Wrap the IO Reader/Writer with a base pass-through reader/writer")
 	flag.BoolVar(&testStructToArray, "ts", false, "Set StructToArray option")
-	flag.BoolVar(&testWriteNoSymbols, "tn", false, "Set NoSymbols option")
 	flag.BoolVar(&testCanonical, "tc", false, "Set Canonical option")
 	flag.BoolVar(&testInternStr, "te", false, "Set InternStr option")
 	flag.BoolVar(&testSkipIntf, "tf", false, "Skip Interfaces")
 	flag.BoolVar(&testUseReset, "tr", false, "Use Reset")
-	flag.IntVar(&testJsonIndent, "td", 0, "Use JSON Indent")
+	flag.IntVar(&testNumRepeatString, "trs", 8, "Create string variables by repeating a string N times")
 	flag.IntVar(&testMaxInitLen, "tx", 0, "Max Init Len")
 	flag.BoolVar(&testUseMust, "tm", true, "Use Must(En|De)code")
 	flag.BoolVar(&testCheckCircRef, "tl", false, "Use Check Circular Ref")
-	flag.BoolVar(&testJsonHTMLCharsAsIs, "tas", false, "Set JSON HTMLCharsAsIs")
-	flag.BoolVar(&testJsonPreferFloat, "tjf", false, "Prefer Float in json")
 }
 
 func benchInitFlags() {
@@ -169,8 +201,8 @@ func testInitAll() {
 	}
 }
 
-func testCodecEncode(ts interface{}, bsIn []byte,
-	fn func([]byte) *bytes.Buffer, h Handle) (bs []byte, err error) {
+func sTestCodecEncode(ts interface{}, bsIn []byte, fn func([]byte) *bytes.Buffer,
+	h Handle, bh *BasicHandle) (bs []byte, err error) {
 	// bs = make([]byte, 0, approxSize)
 	var e *Encoder
 	var buf *bytes.Buffer
@@ -179,9 +211,17 @@ func testCodecEncode(ts interface{}, bsIn []byte,
 	} else {
 		e = NewEncoder(nil, h)
 	}
-	if testUseIoEncDec {
+	var oldWriteBufferSize int
+	if testUseIoEncDec >= 0 {
 		buf = fn(bsIn)
-		e.Reset(buf)
+		// set the encode options for using a buffer
+		oldWriteBufferSize = bh.WriterBufferSize
+		bh.WriterBufferSize = testUseIoEncDec
+		if testUseIoWrapper {
+			e.Reset(ioWriterWrapper{buf})
+		} else {
+			e.Reset(buf)
+		}
 	} else {
 		bs = bsIn
 		e.ResetBytes(&bs)
@@ -191,23 +231,31 @@ func testCodecEncode(ts interface{}, bsIn []byte,
 	} else {
 		err = e.Encode(ts)
 	}
-	if testUseIoEncDec {
+	if testUseIoEncDec >= 0 {
 		bs = buf.Bytes()
+		bh.WriterBufferSize = oldWriteBufferSize
 	}
 	return
 }
 
-func testCodecDecode(bs []byte, ts interface{}, h Handle) (err error) {
+func sTestCodecDecode(bs []byte, ts interface{}, h Handle, bh *BasicHandle) (err error) {
 	var d *Decoder
-	var buf *bytes.Reader
+	// var buf *bytes.Reader
 	if testUseReset {
 		d = testHEDGet(h).D
 	} else {
 		d = NewDecoder(nil, h)
 	}
-	if testUseIoEncDec {
-		buf = bytes.NewReader(bs)
-		d.Reset(buf)
+	var oldReadBufferSize int
+	if testUseIoEncDec >= 0 {
+		buf := bytes.NewReader(bs)
+		oldReadBufferSize = bh.ReaderBufferSize
+		bh.ReaderBufferSize = testUseIoEncDec
+		if testUseIoWrapper {
+			d.Reset(ioReaderWrapper{buf})
+		} else {
+			d.Reset(buf)
+		}
 	} else {
 		d.ResetBytes(bs)
 	}
@@ -216,10 +264,28 @@ func testCodecDecode(bs []byte, ts interface{}, h Handle) (err error) {
 	} else {
 		err = d.Decode(ts)
 	}
+	if testUseIoEncDec >= 0 {
+		bh.ReaderBufferSize = oldReadBufferSize
+	}
 	return
 }
 
-// ----- functions below are used only by benchmarks alone
+// --- functions below are used by both benchmarks and tests
+
+func logT(x interface{}, format string, args ...interface{}) {
+	if t, ok := x.(*testing.T); ok && t != nil {
+		t.Logf(format, args...)
+	} else if b, ok := x.(*testing.B); ok && b != nil {
+		b.Logf(format, args...)
+	} else { // if testing.Verbose() { // if testVerbose {
+		if len(format) == 0 || format[len(format)-1] != '\n' {
+			format = format + "\n"
+		}
+		fmt.Printf(format, args...)
+	}
+}
+
+// --- functions below are used only by benchmarks alone
 
 func fnBenchmarkByteBuf(bsIn []byte) (buf *bytes.Buffer) {
 	// var buf bytes.Buffer
@@ -229,10 +295,10 @@ func fnBenchmarkByteBuf(bsIn []byte) (buf *bytes.Buffer) {
 	return
 }
 
-func benchFnCodecEncode(ts interface{}, bsIn []byte, h Handle) (bs []byte, err error) {
-	return testCodecEncode(ts, bsIn, fnBenchmarkByteBuf, h)
-}
+// func benchFnCodecEncode(ts interface{}, bsIn []byte, h Handle) (bs []byte, err error) {
+// 	return testCodecEncode(ts, bsIn, fnBenchmarkByteBuf, h)
+// }
 
-func benchFnCodecDecode(bs []byte, ts interface{}, h Handle) (err error) {
-	return testCodecDecode(bs, ts, h)
-}
+// func benchFnCodecDecode(bs []byte, ts interface{}, h Handle) (err error) {
+// 	return testCodecDecode(bs, ts, h)
+// }
diff --git a/vendor/github.com/ugorji/go/codec/simple.go b/vendor/github.com/ugorji/go/codec/simple.go
index 209e9887f..0fba1ba59 100644
--- a/vendor/github.com/ugorji/go/codec/simple.go
+++ b/vendor/github.com/ugorji/go/codec/simple.go
@@ -6,6 +6,7 @@ package codec
 import (
 	"math"
 	"reflect"
+	"time"
 )
 
 const (
@@ -20,6 +21,8 @@ const (
 	simpleVdPosInt = 8
 	simpleVdNegInt = 12
 
+	simpleVdTime = 24
+
 	// containers: each lasts for 4 (ie n, n+1, n+2, ... n+7)
 	simpleVdString    = 216
 	simpleVdByteArray = 224
@@ -30,11 +33,13 @@ const (
 
 type simpleEncDriver struct {
 	noBuiltInTypes
-	encNoSeparator
+	encDriverNoopContainerWriter
+	// encNoSeparator
 	e *Encoder
 	h *SimpleHandle
 	w encWriter
 	b [8]byte
+	c containerState
 }
 
 func (e *simpleEncDriver) EncodeNil() {
@@ -42,6 +47,10 @@ func (e *simpleEncDriver) EncodeNil() {
 }
 
 func (e *simpleEncDriver) EncodeBool(b bool) {
+	if e.h.EncZeroValuesAsNil && e.c != containerMapKey && !b {
+		e.EncodeNil()
+		return
+	}
 	if b {
 		e.w.writen1(simpleVdTrue)
 	} else {
@@ -50,11 +59,19 @@ func (e *simpleEncDriver) EncodeBool(b bool) {
 }
 
 func (e *simpleEncDriver) EncodeFloat32(f float32) {
+	if e.h.EncZeroValuesAsNil && e.c != containerMapKey && f == 0.0 {
+		e.EncodeNil()
+		return
+	}
 	e.w.writen1(simpleVdFloat32)
 	bigenHelper{e.b[:4], e.w}.writeUint32(math.Float32bits(f))
 }
 
 func (e *simpleEncDriver) EncodeFloat64(f float64) {
+	if e.h.EncZeroValuesAsNil && e.c != containerMapKey && f == 0.0 {
+		e.EncodeNil()
+		return
+	}
 	e.w.writen1(simpleVdFloat64)
 	bigenHelper{e.b[:8], e.w}.writeUint64(math.Float64bits(f))
 }
@@ -72,6 +89,10 @@ func (e *simpleEncDriver) EncodeUint(v uint64) {
 }
 
 func (e *simpleEncDriver) encUint(v uint64, bd uint8) {
+	if e.h.EncZeroValuesAsNil && e.c != containerMapKey && v == 0 {
+		e.EncodeNil()
+		return
+	}
 	if v <= math.MaxUint8 {
 		e.w.writen2(bd, uint8(v))
 	} else if v <= math.MaxUint16 {
@@ -124,28 +145,75 @@ func (e *simpleEncDriver) encodeExtPreamble(xtag byte, length int) {
 	e.w.writen1(xtag)
 }
 
-func (e *simpleEncDriver) EncodeArrayStart(length int) {
+func (e *simpleEncDriver) WriteArrayStart(length int) {
+	e.c = containerArrayStart
 	e.encLen(simpleVdArray, length)
 }
 
-func (e *simpleEncDriver) EncodeMapStart(length int) {
+func (e *simpleEncDriver) WriteArrayElem() {
+	e.c = containerArrayElem
+}
+
+func (e *simpleEncDriver) WriteArrayEnd() {
+	e.c = containerArrayEnd
+}
+
+func (e *simpleEncDriver) WriteMapStart(length int) {
+	e.c = containerMapStart
 	e.encLen(simpleVdMap, length)
 }
 
+func (e *simpleEncDriver) WriteMapElemKey() {
+	e.c = containerMapKey
+}
+
+func (e *simpleEncDriver) WriteMapElemValue() {
+	e.c = containerMapValue
+}
+
+func (e *simpleEncDriver) WriteMapEnd() {
+	e.c = containerMapEnd
+}
+
 func (e *simpleEncDriver) EncodeString(c charEncoding, v string) {
+	if false && e.h.EncZeroValuesAsNil && e.c != containerMapKey && v == "" {
+		e.EncodeNil()
+		return
+	}
 	e.encLen(simpleVdString, len(v))
 	e.w.writestr(v)
 }
 
 func (e *simpleEncDriver) EncodeSymbol(v string) {
-	e.EncodeString(c_UTF8, v)
+	e.EncodeString(cUTF8, v)
 }
 
 func (e *simpleEncDriver) EncodeStringBytes(c charEncoding, v []byte) {
+	// if e.h.EncZeroValuesAsNil && e.c != containerMapKey && v == nil {
+	if v == nil {
+		e.EncodeNil()
+		return
+	}
 	e.encLen(simpleVdByteArray, len(v))
 	e.w.writeb(v)
 }
 
+func (e *simpleEncDriver) EncodeTime(t time.Time) {
+	// if e.h.EncZeroValuesAsNil && e.c != containerMapKey && t.IsZero() {
+	if t.IsZero() {
+		e.EncodeNil()
+		return
+	}
+	v, err := t.MarshalBinary()
+	if err != nil {
+		e.e.errorv(err)
+		return
+	}
+	// time.Time marshalbinary takes about 14 bytes.
+	e.w.writen2(simpleVdTime, uint8(len(v)))
+	e.w.writeb(v)
+}
+
 //------------------------------------
 
 type simpleDecDriver struct {
@@ -154,11 +222,12 @@ type simpleDecDriver struct {
 	r      decReader
 	bdRead bool
 	bd     byte
-	br     bool // bytes reader
+	br     bool // a bytes reader?
+	c      containerState
+	b      [scratchByteArrayLen]byte
 	noBuiltInTypes
-	noStreamingCodec
-	decNoSeparator
-	b [scratchByteArrayLen]byte
+	// noStreamingCodec
+	decDriverNoopContainerReader
 }
 
 func (d *simpleDecDriver) readNextBd() {
@@ -177,23 +246,23 @@ func (d *simpleDecDriver) ContainerType() (vt valueType) {
 	if !d.bdRead {
 		d.readNextBd()
 	}
-	if d.bd == simpleVdNil {
+	switch d.bd {
+	case simpleVdNil:
 		return valueTypeNil
-	} else if d.bd == simpleVdByteArray || d.bd == simpleVdByteArray+1 ||
-		d.bd == simpleVdByteArray+2 || d.bd == simpleVdByteArray+3 || d.bd == simpleVdByteArray+4 {
+	case simpleVdByteArray, simpleVdByteArray + 1, simpleVdByteArray + 2, simpleVdByteArray + 3, simpleVdByteArray + 4:
 		return valueTypeBytes
-	} else if d.bd == simpleVdString || d.bd == simpleVdString+1 ||
-		d.bd == simpleVdString+2 || d.bd == simpleVdString+3 || d.bd == simpleVdString+4 {
+	case simpleVdString, simpleVdString + 1, simpleVdString + 2, simpleVdString + 3, simpleVdString + 4:
 		return valueTypeString
-	} else if d.bd == simpleVdArray || d.bd == simpleVdArray+1 ||
-		d.bd == simpleVdArray+2 || d.bd == simpleVdArray+3 || d.bd == simpleVdArray+4 {
+	case simpleVdArray, simpleVdArray + 1, simpleVdArray + 2, simpleVdArray + 3, simpleVdArray + 4:
 		return valueTypeArray
-	} else if d.bd == simpleVdMap || d.bd == simpleVdMap+1 ||
-		d.bd == simpleVdMap+2 || d.bd == simpleVdMap+3 || d.bd == simpleVdMap+4 {
+	case simpleVdMap, simpleVdMap + 1, simpleVdMap + 2, simpleVdMap + 3, simpleVdMap + 4:
 		return valueTypeMap
-	} else {
-		// d.d.errorf("isContainerType: unsupported parameter: %v", vt)
+		// case simpleVdTime:
+		// 	return valueTypeTime
 	}
+	// else {
+	// d.d.errorf("isContainerType: unsupported parameter: %v", vt)
+	// }
 	return valueTypeUnset
 }
 
@@ -277,7 +346,7 @@ func (d *simpleDecDriver) DecodeUint(bitsize uint8) (ui uint64) {
 	return
 }
 
-func (d *simpleDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) {
+func (d *simpleDecDriver) DecodeFloat64() (f float64) {
 	if !d.bdRead {
 		d.readNextBd()
 	}
@@ -293,10 +362,6 @@ func (d *simpleDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) {
 			return
 		}
 	}
-	if chkOverflow32 && chkOvf.Float32(f) {
-		d.d.errorf("msgpack: float32 overflow: %v", f)
-		return
-	}
 	d.bdRead = false
 	return
 }
@@ -322,6 +387,7 @@ func (d *simpleDecDriver) ReadMapStart() (length int) {
 		d.readNextBd()
 	}
 	d.bdRead = false
+	d.c = containerMapStart
 	return d.decLen()
 }
 
@@ -330,9 +396,30 @@ func (d *simpleDecDriver) ReadArrayStart() (length int) {
 		d.readNextBd()
 	}
 	d.bdRead = false
+	d.c = containerArrayStart
 	return d.decLen()
 }
 
+func (d *simpleDecDriver) ReadArrayElem() {
+	d.c = containerArrayElem
+}
+
+func (d *simpleDecDriver) ReadArrayEnd() {
+	d.c = containerArrayEnd
+}
+
+func (d *simpleDecDriver) ReadMapElemKey() {
+	d.c = containerMapKey
+}
+
+func (d *simpleDecDriver) ReadMapElemValue() {
+	d.c = containerMapValue
+}
+
+func (d *simpleDecDriver) ReadMapEnd() {
+	d.c = containerMapEnd
+}
+
 func (d *simpleDecDriver) decLen() int {
 	switch d.bd % 8 {
 	case 0:
@@ -376,6 +463,12 @@ func (d *simpleDecDriver) DecodeBytes(bs []byte, zerocopy bool) (bsOut []byte) {
 		d.bdRead = false
 		return
 	}
+	// check if an "array" of uint8's (see ContainerType for how to infer if an array)
+	if d.bd >= simpleVdArray && d.bd <= simpleVdMap+4 {
+		bsOut, _ = fastpathTV.DecSliceUint8V(bs, true, d.d)
+		return
+	}
+
 	clen := d.decLen()
 	d.bdRead = false
 	if zerocopy {
@@ -388,6 +481,27 @@ func (d *simpleDecDriver) DecodeBytes(bs []byte, zerocopy bool) (bsOut []byte) {
 	return decByteSlice(d.r, clen, d.d.h.MaxInitLen, bs)
 }
 
+func (d *simpleDecDriver) DecodeTime() (t time.Time) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
+	if d.bd == simpleVdNil {
+		d.bdRead = false
+		return
+	}
+	if d.bd != simpleVdTime {
+		d.d.errorf("invalid descriptor for time.Time - expect 0x%x, received 0x%x", simpleVdTime, d.bd)
+		return
+	}
+	d.bdRead = false
+	clen := int(d.r.readn1())
+	b := d.r.readx(clen)
+	if err := (&t).UnmarshalBinary(b); err != nil {
+		d.d.errorv(err)
+	}
+	return
+}
+
 func (d *simpleDecDriver) DecodeExt(rv interface{}, xtag uint64, ext Ext) (realxtag uint64) {
 	if xtag > 0xff {
 		d.d.errorf("decodeExt: tag must be <= 0xff; got: %v", xtag)
@@ -421,7 +535,7 @@ func (d *simpleDecDriver) decodeExtV(verifyTag bool, tag byte) (xtag byte, xbs [
 	case simpleVdByteArray, simpleVdByteArray + 1, simpleVdByteArray + 2, simpleVdByteArray + 3, simpleVdByteArray + 4:
 		xbs = d.DecodeBytes(nil, true)
 	default:
-		d.d.errorf("Invalid d.bd for extensions (Expecting extensions or byte array). Got: 0x%x", d.bd)
+		d.d.errorf("Invalid descriptor for extensions (Expecting extensions or byte array). Got: 0x%x", d.bd)
 		return
 	}
 	d.bdRead = false
@@ -433,7 +547,7 @@ func (d *simpleDecDriver) DecodeNaked() {
 		d.readNextBd()
 	}
 
-	n := &d.d.n
+	n := d.d.n
 	var decodeFurther bool
 
 	switch d.bd {
@@ -458,10 +572,13 @@ func (d *simpleDecDriver) DecodeNaked() {
 		n.i = d.DecodeInt(64)
 	case simpleVdFloat32:
 		n.v = valueTypeFloat
-		n.f = d.DecodeFloat(true)
+		n.f = d.DecodeFloat64()
 	case simpleVdFloat64:
 		n.v = valueTypeFloat
-		n.f = d.DecodeFloat(false)
+		n.f = d.DecodeFloat64()
+	case simpleVdTime:
+		n.v = valueTypeTime
+		n.t = d.DecodeTime()
 	case simpleVdString, simpleVdString + 1, simpleVdString + 2, simpleVdString + 3, simpleVdString + 4:
 		n.v = valueTypeString
 		n.s = d.DecodeString()
@@ -499,7 +616,7 @@ func (d *simpleDecDriver) DecodeNaked() {
 //   - Integers (intXXX, uintXXX) are encoded in 1, 2, 4 or 8 bytes (plus a descriptor byte).
 //     There are positive (uintXXX and intXXX >= 0) and negative (intXXX < 0) integers.
 //   - Floats are encoded in 4 or 8 bytes (plus a descriptor byte)
-//   - Lenght of containers (strings, bytes, array, map, extensions)
+//   - Length of containers (strings, bytes, array, map, extensions)
 //     are encoded in 0, 1, 2, 4 or 8 bytes.
 //     Zero-length containers have no length encoded.
 //     For others, the number of bytes is given by pow(2, bd%3)
@@ -507,17 +624,27 @@ func (d *simpleDecDriver) DecodeNaked() {
 //   - arrays are encoded as [bd] [length] [value]...
 //   - extensions are encoded as [bd] [length] [tag] [byte]...
 //   - strings/bytearrays are encoded as [bd] [length] [byte]...
+//   - time.Time are encoded as [bd] [length] [byte]...
 //
 // The full spec will be published soon.
 type SimpleHandle struct {
 	BasicHandle
 	binaryEncodingType
+	noElemSeparators
+	// EncZeroValuesAsNil says to encode zero values for numbers, bool, string, etc as nil
+	EncZeroValuesAsNil bool
 }
 
+// Name returns the name of the handle: simple
+func (h *SimpleHandle) Name() string { return "simple" }
+
+// SetBytesExt sets an extension
 func (h *SimpleHandle) SetBytesExt(rt reflect.Type, tag uint64, ext BytesExt) (err error) {
 	return h.SetExt(rt, tag, &setExtWrapper{b: ext})
 }
 
+func (h *SimpleHandle) hasElemSeparators() bool { return true } // as it implements Write(Map|Array)XXX
+
 func (h *SimpleHandle) newEncDriver(e *Encoder) encDriver {
 	return &simpleEncDriver{e: e, w: e.w, h: h}
 }
@@ -527,10 +654,12 @@ func (h *SimpleHandle) newDecDriver(d *Decoder) decDriver {
 }
 
 func (e *simpleEncDriver) reset() {
+	e.c = 0
 	e.w = e.e.w
 }
 
 func (d *simpleDecDriver) reset() {
+	d.c = 0
 	d.r, d.br = d.d.r, d.d.bytes
 	d.bd, d.bdRead = 0, false
 }
diff --git a/vendor/github.com/ugorji/go/codec/test-cbor-goldens.json b/vendor/github.com/ugorji/go/codec/test-cbor-goldens.json
deleted file mode 100644
index 902858671..000000000
--- a/vendor/github.com/ugorji/go/codec/test-cbor-goldens.json
+++ /dev/null
@@ -1,639 +0,0 @@
-[
-  {
-    "cbor": "AA==",
-    "hex": "00",
-    "roundtrip": true,
-    "decoded": 0
-  },
-  {
-    "cbor": "AQ==",
-    "hex": "01",
-    "roundtrip": true,
-    "decoded": 1
-  },
-  {
-    "cbor": "Cg==",
-    "hex": "0a",
-    "roundtrip": true,
-    "decoded": 10
-  },
-  {
-    "cbor": "Fw==",
-    "hex": "17",
-    "roundtrip": true,
-    "decoded": 23
-  },
-  {
-    "cbor": "GBg=",
-    "hex": "1818",
-    "roundtrip": true,
-    "decoded": 24
-  },
-  {
-    "cbor": "GBk=",
-    "hex": "1819",
-    "roundtrip": true,
-    "decoded": 25
-  },
-  {
-    "cbor": "GGQ=",
-    "hex": "1864",
-    "roundtrip": true,
-    "decoded": 100
-  },
-  {
-    "cbor": "GQPo",
-    "hex": "1903e8",
-    "roundtrip": true,
-    "decoded": 1000
-  },
-  {
-    "cbor": "GgAPQkA=",
-    "hex": "1a000f4240",
-    "roundtrip": true,
-    "decoded": 1000000
-  },
-  {
-    "cbor": "GwAAAOjUpRAA",
-    "hex": "1b000000e8d4a51000",
-    "roundtrip": true,
-    "decoded": 1000000000000
-  },
-  {
-    "cbor": "G///////////",
-    "hex": "1bffffffffffffffff",
-    "roundtrip": true,
-    "decoded": 18446744073709551615
-  },
-  {
-    "cbor": "wkkBAAAAAAAAAAA=",
-    "hex": "c249010000000000000000",
-    "roundtrip": true,
-    "decoded": 18446744073709551616
-  },
-  {
-    "cbor": "O///////////",
-    "hex": "3bffffffffffffffff",
-    "roundtrip": true,
-    "decoded": -18446744073709551616,
-    "skip": true
-  },
-  {
-    "cbor": "w0kBAAAAAAAAAAA=",
-    "hex": "c349010000000000000000",
-    "roundtrip": true,
-    "decoded": -18446744073709551617
-  },
-  {
-    "cbor": "IA==",
-    "hex": "20",
-    "roundtrip": true,
-    "decoded": -1
-  },
-  {
-    "cbor": "KQ==",
-    "hex": "29",
-    "roundtrip": true,
-    "decoded": -10
-  },
-  {
-    "cbor": "OGM=",
-    "hex": "3863",
-    "roundtrip": true,
-    "decoded": -100
-  },
-  {
-    "cbor": "OQPn",
-    "hex": "3903e7",
-    "roundtrip": true,
-    "decoded": -1000
-  },
-  {
-    "cbor": "+QAA",
-    "hex": "f90000",
-    "roundtrip": true,
-    "decoded": 0.0
-  },
-  {
-    "cbor": "+YAA",
-    "hex": "f98000",
-    "roundtrip": true,
-    "decoded": -0.0
-  },
-  {
-    "cbor": "+TwA",
-    "hex": "f93c00",
-    "roundtrip": true,
-    "decoded": 1.0
-  },
-  {
-    "cbor": "+z/xmZmZmZma",
-    "hex": "fb3ff199999999999a",
-    "roundtrip": true,
-    "decoded": 1.1
-  },
-  {
-    "cbor": "+T4A",
-    "hex": "f93e00",
-    "roundtrip": true,
-    "decoded": 1.5
-  },
-  {
-    "cbor": "+Xv/",
-    "hex": "f97bff",
-    "roundtrip": true,
-    "decoded": 65504.0
-  },
-  {
-    "cbor": "+kfDUAA=",
-    "hex": "fa47c35000",
-    "roundtrip": true,
-    "decoded": 100000.0
-  },
-  {
-    "cbor": "+n9///8=",
-    "hex": "fa7f7fffff",
-    "roundtrip": true,
-    "decoded": 3.4028234663852886e+38
-  },
-  {
-    "cbor": "+3435DyIAHWc",
-    "hex": "fb7e37e43c8800759c",
-    "roundtrip": true,
-    "decoded": 1.0e+300
-  },
-  {
-    "cbor": "+QAB",
-    "hex": "f90001",
-    "roundtrip": true,
-    "decoded": 5.960464477539063e-08
-  },
-  {
-    "cbor": "+QQA",
-    "hex": "f90400",
-    "roundtrip": true,
-    "decoded": 6.103515625e-05
-  },
-  {
-    "cbor": "+cQA",
-    "hex": "f9c400",
-    "roundtrip": true,
-    "decoded": -4.0
-  },
-  {
-    "cbor": "+8AQZmZmZmZm",
-    "hex": "fbc010666666666666",
-    "roundtrip": true,
-    "decoded": -4.1
-  },
-  {
-    "cbor": "+XwA",
-    "hex": "f97c00",
-    "roundtrip": true,
-    "diagnostic": "Infinity"
-  },
-  {
-    "cbor": "+X4A",
-    "hex": "f97e00",
-    "roundtrip": true,
-    "diagnostic": "NaN"
-  },
-  {
-    "cbor": "+fwA",
-    "hex": "f9fc00",
-    "roundtrip": true,
-    "diagnostic": "-Infinity"
-  },
-  {
-    "cbor": "+n+AAAA=",
-    "hex": "fa7f800000",
-    "roundtrip": false,
-    "diagnostic": "Infinity"
-  },
-  {
-    "cbor": "+n/AAAA=",
-    "hex": "fa7fc00000",
-    "roundtrip": false,
-    "diagnostic": "NaN"
-  },
-  {
-    "cbor": "+v+AAAA=",
-    "hex": "faff800000",
-    "roundtrip": false,
-    "diagnostic": "-Infinity"
-  },
-  {
-    "cbor": "+3/wAAAAAAAA",
-    "hex": "fb7ff0000000000000",
-    "roundtrip": false,
-    "diagnostic": "Infinity"
-  },
-  {
-    "cbor": "+3/4AAAAAAAA",
-    "hex": "fb7ff8000000000000",
-    "roundtrip": false,
-    "diagnostic": "NaN"
-  },
-  {
-    "cbor": "+//wAAAAAAAA",
-    "hex": "fbfff0000000000000",
-    "roundtrip": false,
-    "diagnostic": "-Infinity"
-  },
-  {
-    "cbor": "9A==",
-    "hex": "f4",
-    "roundtrip": true,
-    "decoded": false
-  },
-  {
-    "cbor": "9Q==",
-    "hex": "f5",
-    "roundtrip": true,
-    "decoded": true
-  },
-  {
-    "cbor": "9g==",
-    "hex": "f6",
-    "roundtrip": true,
-    "decoded": null
-  },
-  {
-    "cbor": "9w==",
-    "hex": "f7",
-    "roundtrip": true,
-    "diagnostic": "undefined"
-  },
-  {
-    "cbor": "8A==",
-    "hex": "f0",
-    "roundtrip": true,
-    "diagnostic": "simple(16)"
-  },
-  {
-    "cbor": "+Bg=",
-    "hex": "f818",
-    "roundtrip": true,
-    "diagnostic": "simple(24)"
-  },
-  {
-    "cbor": "+P8=",
-    "hex": "f8ff",
-    "roundtrip": true,
-    "diagnostic": "simple(255)"
-  },
-  {
-    "cbor": "wHQyMDEzLTAzLTIxVDIwOjA0OjAwWg==",
-    "hex": "c074323031332d30332d32315432303a30343a30305a",
-    "roundtrip": true,
-    "diagnostic": "0(\"2013-03-21T20:04:00Z\")"
-  },
-  {
-    "cbor": "wRpRS2ew",
-    "hex": "c11a514b67b0",
-    "roundtrip": true,
-    "diagnostic": "1(1363896240)"
-  },
-  {
-    "cbor": "wftB1FLZ7CAAAA==",
-    "hex": "c1fb41d452d9ec200000",
-    "roundtrip": true,
-    "diagnostic": "1(1363896240.5)"
-  },
-  {
-    "cbor": "10QBAgME",
-    "hex": "d74401020304",
-    "roundtrip": true,
-    "diagnostic": "23(h'01020304')"
-  },
-  {
-    "cbor": "2BhFZElFVEY=",
-    "hex": "d818456449455446",
-    "roundtrip": true,
-    "diagnostic": "24(h'6449455446')"
-  },
-  {
-    "cbor": "2CB2aHR0cDovL3d3dy5leGFtcGxlLmNvbQ==",
-    "hex": "d82076687474703a2f2f7777772e6578616d706c652e636f6d",
-    "roundtrip": true,
-    "diagnostic": "32(\"http://www.example.com\")"
-  },
-  {
-    "cbor": "QA==",
-    "hex": "40",
-    "roundtrip": true,
-    "diagnostic": "h''"
-  },
-  {
-    "cbor": "RAECAwQ=",
-    "hex": "4401020304",
-    "roundtrip": true,
-    "diagnostic": "h'01020304'"
-  },
-  {
-    "cbor": "YA==",
-    "hex": "60",
-    "roundtrip": true,
-    "decoded": ""
-  },
-  {
-    "cbor": "YWE=",
-    "hex": "6161",
-    "roundtrip": true,
-    "decoded": "a"
-  },
-  {
-    "cbor": "ZElFVEY=",
-    "hex": "6449455446",
-    "roundtrip": true,
-    "decoded": "IETF"
-  },
-  {
-    "cbor": "YiJc",
-    "hex": "62225c",
-    "roundtrip": true,
-    "decoded": "\"\\"
-  },
-  {
-    "cbor": "YsO8",
-    "hex": "62c3bc",
-    "roundtrip": true,
-    "decoded": "ü"
-  },
-  {
-    "cbor": "Y+awtA==",
-    "hex": "63e6b0b4",
-    "roundtrip": true,
-    "decoded": "水"
-  },
-  {
-    "cbor": "ZPCQhZE=",
-    "hex": "64f0908591",
-    "roundtrip": true,
-    "decoded": "𐅑"
-  },
-  {
-    "cbor": "gA==",
-    "hex": "80",
-    "roundtrip": true,
-    "decoded": [
-
-    ]
-  },
-  {
-    "cbor": "gwECAw==",
-    "hex": "83010203",
-    "roundtrip": true,
-    "decoded": [
-      1,
-      2,
-      3
-    ]
-  },
-  {
-    "cbor": "gwGCAgOCBAU=",
-    "hex": "8301820203820405",
-    "roundtrip": true,
-    "decoded": [
-      1,
-      [
-        2,
-        3
-      ],
-      [
-        4,
-        5
-      ]
-    ]
-  },
-  {
-    "cbor": "mBkBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgYGBk=",
-    "hex": "98190102030405060708090a0b0c0d0e0f101112131415161718181819",
-    "roundtrip": true,
-    "decoded": [
-      1,
-      2,
-      3,
-      4,
-      5,
-      6,
-      7,
-      8,
-      9,
-      10,
-      11,
-      12,
-      13,
-      14,
-      15,
-      16,
-      17,
-      18,
-      19,
-      20,
-      21,
-      22,
-      23,
-      24,
-      25
-    ]
-  },
-  {
-    "cbor": "oA==",
-    "hex": "a0",
-    "roundtrip": true,
-    "decoded": {
-    }
-  },
-  {
-    "cbor": "ogECAwQ=",
-    "hex": "a201020304",
-    "roundtrip": true,
-    "skip": true,
-    "diagnostic": "{1: 2, 3: 4}"
-  },
-  {
-    "cbor": "omFhAWFiggID",
-    "hex": "a26161016162820203",
-    "roundtrip": true,
-    "decoded": {
-      "a": 1,
-      "b": [
-        2,
-        3
-      ]
-    }
-  },
-  {
-    "cbor": "gmFhoWFiYWM=",
-    "hex": "826161a161626163",
-    "roundtrip": true,
-    "decoded": [
-      "a",
-      {
-        "b": "c"
-      }
-    ]
-  },
-  {
-    "cbor": "pWFhYUFhYmFCYWNhQ2FkYURhZWFF",
-    "hex": "a56161614161626142616361436164614461656145",
-    "roundtrip": true,
-    "decoded": {
-      "a": "A",
-      "b": "B",
-      "c": "C",
-      "d": "D",
-      "e": "E"
-    }
-  },
-  {
-    "cbor": "X0IBAkMDBAX/",
-    "hex": "5f42010243030405ff",
-    "roundtrip": false,
-    "skip": true,
-    "diagnostic": "(_ h'0102', h'030405')"
-  },
-  {
-    "cbor": "f2VzdHJlYWRtaW5n/w==",
-    "hex": "7f657374726561646d696e67ff",
-    "roundtrip": false,
-    "decoded": "streaming"
-  },
-  {
-    "cbor": "n/8=",
-    "hex": "9fff",
-    "roundtrip": false,
-    "decoded": [
-
-    ]
-  },
-  {
-    "cbor": "nwGCAgOfBAX//w==",
-    "hex": "9f018202039f0405ffff",
-    "roundtrip": false,
-    "decoded": [
-      1,
-      [
-        2,
-        3
-      ],
-      [
-        4,
-        5
-      ]
-    ]
-  },
-  {
-    "cbor": "nwGCAgOCBAX/",
-    "hex": "9f01820203820405ff",
-    "roundtrip": false,
-    "decoded": [
-      1,
-      [
-        2,
-        3
-      ],
-      [
-        4,
-        5
-      ]
-    ]
-  },
-  {
-    "cbor": "gwGCAgOfBAX/",
-    "hex": "83018202039f0405ff",
-    "roundtrip": false,
-    "decoded": [
-      1,
-      [
-        2,
-        3
-      ],
-      [
-        4,
-        5
-      ]
-    ]
-  },
-  {
-    "cbor": "gwGfAgP/ggQF",
-    "hex": "83019f0203ff820405",
-    "roundtrip": false,
-    "decoded": [
-      1,
-      [
-        2,
-        3
-      ],
-      [
-        4,
-        5
-      ]
-    ]
-  },
-  {
-    "cbor": "nwECAwQFBgcICQoLDA0ODxAREhMUFRYXGBgYGf8=",
-    "hex": "9f0102030405060708090a0b0c0d0e0f101112131415161718181819ff",
-    "roundtrip": false,
-    "decoded": [
-      1,
-      2,
-      3,
-      4,
-      5,
-      6,
-      7,
-      8,
-      9,
-      10,
-      11,
-      12,
-      13,
-      14,
-      15,
-      16,
-      17,
-      18,
-      19,
-      20,
-      21,
-      22,
-      23,
-      24,
-      25
-    ]
-  },
-  {
-    "cbor": "v2FhAWFinwID//8=",
-    "hex": "bf61610161629f0203ffff",
-    "roundtrip": false,
-    "decoded": {
-      "a": 1,
-      "b": [
-        2,
-        3
-      ]
-    }
-  },
-  {
-    "cbor": "gmFhv2FiYWP/",
-    "hex": "826161bf61626163ff",
-    "roundtrip": false,
-    "decoded": [
-      "a",
-      {
-        "b": "c"
-      }
-    ]
-  },
-  {
-    "cbor": "v2NGdW71Y0FtdCH/",
-    "hex": "bf6346756ef563416d7421ff",
-    "roundtrip": false,
-    "decoded": {
-      "Fun": true,
-      "Amt": -2
-    }
-  }
-]
diff --git a/vendor/github.com/ugorji/go/codec/test.py b/vendor/github.com/ugorji/go/codec/test.py
deleted file mode 100755
index 800376f68..000000000
--- a/vendor/github.com/ugorji/go/codec/test.py
+++ /dev/null
@@ -1,126 +0,0 @@
-#!/usr/bin/env python
-
-# This will create golden files in a directory passed to it.
-# A Test calls this internally to create the golden files
-# So it can process them (so we don't have to checkin the files).
-
-# Ensure msgpack-python and cbor are installed first, using:
-#   sudo apt-get install python-dev
-#   sudo apt-get install python-pip
-#   pip install --user msgpack-python msgpack-rpc-python cbor
-
-# Ensure all "string" keys are utf strings (else encoded as bytes)
-
-import cbor, msgpack, msgpackrpc, sys, os, threading
-
-def get_test_data_list():
-    # get list with all primitive types, and a combo type
-    l0 = [ 
-        -8,
-         -1616,
-         -32323232,
-         -6464646464646464,
-         192,
-         1616,
-         32323232,
-         6464646464646464,
-         192,
-         -3232.0,
-         -6464646464.0,
-         3232.0,
-         6464.0,
-         6464646464.0,
-         False,
-         True,
-         u"null",
-         None,
-         u"some&day>some<day",
-         1328176922000002000,
-         u"",
-         -2206187877999998000,
-         u"bytestring",
-         270,
-         u"none",
-        -2013855847999995777,
-         #-6795364578871345152,
-         ]
-    l1 = [
-        { "true": True,
-          "false": False },
-        { "true": u"True",
-          "false": False,
-          "uint16(1616)": 1616 },
-        { "list": [1616, 32323232, True, -3232.0, {"TRUE":True, "FALSE":False}, [True, False] ],
-          "int32":32323232, "bool": True, 
-          "LONG STRING": u"123456789012345678901234567890123456789012345678901234567890",
-          "SHORT STRING": u"1234567890" },
-        { True: "true", 138: False, "false": 200 }
-        ]
-    
-    l = []
-    l.extend(l0)
-    l.append(l0)
-    l.append(1)
-    l.extend(l1)
-    return l
-
-def build_test_data(destdir):
-    l = get_test_data_list()
-    for i in range(len(l)):
-        # packer = msgpack.Packer()
-        serialized = msgpack.dumps(l[i])
-        f = open(os.path.join(destdir, str(i) + '.msgpack.golden'), 'wb')
-        f.write(serialized)
-        f.close()
-        serialized = cbor.dumps(l[i])
-        f = open(os.path.join(destdir, str(i) + '.cbor.golden'), 'wb')
-        f.write(serialized)
-        f.close()
-
-def doRpcServer(port, stopTimeSec):
-    class EchoHandler(object):
-        def Echo123(self, msg1, msg2, msg3):
-            return ("1:%s 2:%s 3:%s" % (msg1, msg2, msg3))
-        def EchoStruct(self, msg):
-            return ("%s" % msg)
-    
-    addr = msgpackrpc.Address('127.0.0.1', port)
-    server = msgpackrpc.Server(EchoHandler())
-    server.listen(addr)
-    # run thread to stop it after stopTimeSec seconds if > 0
-    if stopTimeSec > 0:
-        def myStopRpcServer():
-            server.stop()
-        t = threading.Timer(stopTimeSec, myStopRpcServer)
-        t.start()
-    server.start()
-
-def doRpcClientToPythonSvc(port):
-    address = msgpackrpc.Address('127.0.0.1', port)
-    client = msgpackrpc.Client(address, unpack_encoding='utf-8')
-    print client.call("Echo123", "A1", "B2", "C3")
-    print client.call("EchoStruct", {"A" :"Aa", "B":"Bb", "C":"Cc"})
-   
-def doRpcClientToGoSvc(port):
-    # print ">>>> port: ", port, " <<<<<"
-    address = msgpackrpc.Address('127.0.0.1', port)
-    client = msgpackrpc.Client(address, unpack_encoding='utf-8')
-    print client.call("TestRpcInt.Echo123", ["A1", "B2", "C3"])
-    print client.call("TestRpcInt.EchoStruct", {"A" :"Aa", "B":"Bb", "C":"Cc"})
-
-def doMain(args):
-    if len(args) == 2 and args[0] == "testdata":
-        build_test_data(args[1])
-    elif len(args) == 3 and args[0] == "rpc-server":
-        doRpcServer(int(args[1]), int(args[2]))
-    elif len(args) == 2 and args[0] == "rpc-client-python-service":
-        doRpcClientToPythonSvc(int(args[1]))
-    elif len(args) == 2 and args[0] == "rpc-client-go-service":
-        doRpcClientToGoSvc(int(args[1]))
-    else:
-        print("Usage: test.py " + 
-              "[testdata|rpc-server|rpc-client-python-service|rpc-client-go-service] ...")
-    
-if __name__ == "__main__":
-    doMain(sys.argv[1:])
-
diff --git a/vendor/github.com/ugorji/go/codec/time.go b/vendor/github.com/ugorji/go/codec/time.go
index 3401cf947..692a11b68 100644
--- a/vendor/github.com/ugorji/go/codec/time.go
+++ b/vendor/github.com/ugorji/go/codec/time.go
@@ -3,40 +3,9 @@
 
 package codec
 
-import (
-	"fmt"
-	"time"
-)
+import "time"
 
-var timeDigits = [...]byte{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}
-
-type timeExt struct{}
-
-func (x timeExt) WriteExt(v interface{}) (bs []byte) {
-	switch v2 := v.(type) {
-	case time.Time:
-		bs = encodeTime(v2)
-	case *time.Time:
-		bs = encodeTime(*v2)
-	default:
-		panic(fmt.Errorf("unsupported format for time conversion: expecting time.Time; got %T", v2))
-	}
-	return
-}
-func (x timeExt) ReadExt(v interface{}, bs []byte) {
-	tt, err := decodeTime(bs)
-	if err != nil {
-		panic(err)
-	}
-	*(v.(*time.Time)) = tt
-}
-
-func (x timeExt) ConvertExt(v interface{}) interface{} {
-	return x.WriteExt(v)
-}
-func (x timeExt) UpdateExt(v interface{}, src interface{}) {
-	x.ReadExt(v, src.([]byte))
-}
+// var timeDigits = [...]byte{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}
 
 // EncodeTime encodes a time.Time as a []byte, including
 // information on the instant in time and UTC offset.
@@ -176,13 +145,12 @@ func decodeTime(bs []byte) (tt time.Time, err error) {
 
 	i2 = i + 2
 	tz = bigen.Uint16(bs[i:i2])
-	i = i2
+	// i = i2
 	// sign extend sign bit into top 2 MSB (which were dst bits):
 	if tz&(1<<13) == 0 { // positive
 		tz = tz & 0x3fff //clear 2 MSBs: dst bits
 	} else { // negative
 		tz = tz | 0xc000 //set 2 MSBs: dst bits
-		//tzname[3] = '-' (TODO: verify. this works here)
 	}
 	tzint := int16(tz)
 	if tzint == 0 {
@@ -197,24 +165,24 @@ func decodeTime(bs []byte) (tt time.Time, err error) {
 	return
 }
 
-func timeLocUTCName(tzint int16) string {
-	if tzint == 0 {
-		return "UTC"
-	}
-	var tzname = []byte("UTC+00:00")
-	//tzname := fmt.Sprintf("UTC%s%02d:%02d", tzsign, tz/60, tz%60) //perf issue using Sprintf. inline below.
-	//tzhr, tzmin := tz/60, tz%60 //faster if u convert to int first
-	var tzhr, tzmin int16
-	if tzint < 0 {
-		tzname[3] = '-' // (TODO: verify. this works here)
-		tzhr, tzmin = -tzint/60, (-tzint)%60
-	} else {
-		tzhr, tzmin = tzint/60, tzint%60
-	}
-	tzname[4] = timeDigits[tzhr/10]
-	tzname[5] = timeDigits[tzhr%10]
-	tzname[7] = timeDigits[tzmin/10]
-	tzname[8] = timeDigits[tzmin%10]
-	return string(tzname)
-	//return time.FixedZone(string(tzname), int(tzint)*60)
-}
+// func timeLocUTCName(tzint int16) string {
+// 	if tzint == 0 {
+// 		return "UTC"
+// 	}
+// 	var tzname = []byte("UTC+00:00")
+// 	//tzname := fmt.Sprintf("UTC%s%02d:%02d", tzsign, tz/60, tz%60) //perf issue using Sprintf. inline below.
+// 	//tzhr, tzmin := tz/60, tz%60 //faster if u convert to int first
+// 	var tzhr, tzmin int16
+// 	if tzint < 0 {
+// 		tzname[3] = '-' // (TODO: verify. this works here)
+// 		tzhr, tzmin = -tzint/60, (-tzint)%60
+// 	} else {
+// 		tzhr, tzmin = tzint/60, tzint%60
+// 	}
+// 	tzname[4] = timeDigits[tzhr/10]
+// 	tzname[5] = timeDigits[tzhr%10]
+// 	tzname[7] = timeDigits[tzmin/10]
+// 	tzname[8] = timeDigits[tzmin%10]
+// 	return string(tzname)
+// 	//return time.FixedZone(string(tzname), int(tzint)*60)
+// }
diff --git a/vendor/github.com/ugorji/go/codec/values_test.go b/vendor/github.com/ugorji/go/codec/values_test.go
index 2c0d4b030..341ec3866 100644
--- a/vendor/github.com/ugorji/go/codec/values_test.go
+++ b/vendor/github.com/ugorji/go/codec/values_test.go
@@ -6,46 +6,78 @@
 package codec
 
 // This file contains values used by tests and benchmarks.
-// JSON/BSON do not like maps with keys that are not strings,
-// so we only use maps with string keys here.
+// The benchmarks will test performance against other libraries (encoding/json, json-iterator, bson, gob, etc).
+// Consequently, we only use values that will parse well in all engines,
+// and only leverage features that work across multiple libraries for a truer comparison.
+// For example,
+// - JSON/BSON do not like maps with keys that are not strings,
+//   so we only use maps with string keys here.
+// - _struct options are not honored by other libraries,
+//   so we don't use them in this file.
 
 import (
 	"math"
-	"time"
+	"strings"
 )
 
-var testStrucTime = time.Date(2012, 2, 2, 2, 2, 2, 2000, time.UTC).UTC()
+type wrapSliceUint64 []uint64
+type wrapSliceString []string
+type wrapUint64 uint64
+type wrapString string
+type wrapUint64Slice []wrapUint64
+type wrapStringSlice []wrapString
+
+type stringUint64T struct {
+	S string
+	U uint64
+}
 
 type AnonInTestStruc struct {
-	AS        string
-	AI64      int64
-	AI16      int16
-	AUi64     uint64
-	ASslice   []string
-	AI64slice []int64
-	AF64slice []float64
+	AS         string
+	AI64       int64
+	AI16       int16
+	AUi64      uint64
+	ASslice    []string
+	AI64slice  []int64
+	AUi64slice []uint64
+	AF64slice  []float64
+	AF32slice  []float32
+
 	// AMI32U32  map[int32]uint32
 	// AMU32F64 map[uint32]float64 // json/bson do not like it
 	AMSU16 map[string]uint16
+
+	// use these to test 0-len or nil slices/maps/arrays
+	AI64arr0    [0]int64
+	A164slice0  []int64
+	AUi64sliceN []uint64
+	AMSU16N     map[string]uint16
+	AMSU16E     map[string]uint16
 }
 
-type AnonInTestStrucIntf struct {
-	Islice []interface{}
-	Ms     map[string]interface{}
-	Nintf  interface{} //don't set this, so we can test for nil
-	T      time.Time
-}
+type testSimpleFields struct {
+	S string
 
-type TestStruc struct {
-	_struct struct{} `codec:",omitempty"` //set omitempty for every field
+	I64 int64
+	I32 int32
+	I16 int16
+	I8  int8
+
+	I64n int64
+	I32n int32
+	I16n int16
+	I8n  int8
 
-	S    string
-	I64  int64
-	I16  int16
 	Ui64 uint64
+	Ui32 uint32
+	Ui16 uint16
 	Ui8  uint8
-	B    bool
-	By   uint8 // byte: msgp doesn't like byte
+
+	F64 float64
+	F32 float32
+
+	B  bool
+	By uint8 // byte: msgp doesn't like byte
 
 	Sslice    []string
 	I64slice  []int64
@@ -57,51 +89,191 @@ type TestStruc struct {
 
 	Iptrslice []*int64
 
-	// TODO: test these separately, specifically for reflection and codecgen.
-	// Unfortunately, ffjson doesn't support these. Its compilation even fails.
-	// Ui64array      [4]uint64
-	// Ui64slicearray [][4]uint64
+	WrapSliceInt64  wrapSliceUint64
+	WrapSliceString wrapSliceString
+
+	Msi64 map[string]int64
+}
+
+type TestStrucCommon struct {
+	S string
+
+	I64 int64
+	I32 int32
+	I16 int16
+	I8  int8
+
+	I64n int64
+	I32n int32
+	I16n int16
+	I8n  int8
+
+	Ui64 uint64
+	Ui32 uint32
+	Ui16 uint16
+	Ui8  uint8
+
+	F64 float64
+	F32 float32
+
+	B  bool
+	By uint8 // byte: msgp doesn't like byte
+
+	Sslice    []string
+	I64slice  []int64
+	I16slice  []int16
+	Ui64slice []uint64
+	Ui8slice  []uint8
+	Bslice    []bool
+	Byslice   []byte
+
+	Iptrslice []*int64
+
+	WrapSliceInt64  wrapSliceUint64
+	WrapSliceString wrapSliceString
+
+	Msi64 map[string]int64
+
+	Simplef testSimpleFields
+
+	SstrUi64T []stringUint64T
 
 	AnonInTestStruc
 
-	//M map[interface{}]interface{}  `json:"-",bson:"-"`
-	Msi64 map[string]int64
+	NotAnon AnonInTestStruc
 
-	// make this a ptr, so that it could be set or not.
-	// for comparison (e.g. with msgp), give it a struct tag (so it is not inlined),
-	// make this one omitempty (so it is included if nil).
-	*AnonInTestStrucIntf `codec:",omitempty"`
+	// R          Raw // Testing Raw must be explicitly turned on, so use standalone test
+	// Rext RawExt // Testing RawExt is tricky, so use standalone test
+
+	Nmap   map[string]bool //don't set this, so we can test for nil
+	Nslice []byte          //don't set this, so we can test for nil
+	Nint64 *int64          //don't set this, so we can test for nil
+}
+
+type TestStruc struct {
+	// _struct struct{} `json:",omitempty"` //set omitempty for every field
+
+	TestStrucCommon
 
-	Nmap       map[string]bool //don't set this, so we can test for nil
-	Nslice     []byte          //don't set this, so we can test for nil
-	Nint64     *int64          //don't set this, so we can test for nil
 	Mtsptr     map[string]*TestStruc
 	Mts        map[string]TestStruc
 	Its        []*TestStruc
 	Nteststruc *TestStruc
 }
 
-// small struct for testing that codecgen works for unexported types
-type tLowerFirstLetter struct {
-	I int
-	u uint64
-	S string
-	b []byte
-}
-
-func newTestStruc(depth int, bench bool, useInterface, useStringKeyOnly bool) (ts *TestStruc) {
+func populateTestStrucCommon(ts *TestStrucCommon, n int, bench, useInterface, useStringKeyOnly bool) {
 	var i64a, i64b, i64c, i64d int64 = 64, 6464, 646464, 64646464
 
-	ts = &TestStruc{
-		S:    "some string",
-		I64:  math.MaxInt64 * 2 / 3, // 64,
-		I16:  1616,
-		Ui64: uint64(int64(math.MaxInt64 * 2 / 3)), // 64, //don't use MaxUint64, as bson can't write it
-		Ui8:  160,
-		B:    true,
-		By:   5,
+	// if bench, do not use uint64 values > math.MaxInt64, as bson, etc cannot decode them
 
-		Sslice:    []string{"one", "two", "three"},
+	var a = AnonInTestStruc{
+		// There's more leeway in altering this.
+		AS:    strRpt(n, "A-String"),
+		AI64:  -64646464,
+		AI16:  1616,
+		AUi64: 64646464,
+		// (U+1D11E)G-clef character may be represented in json as "\uD834\uDD1E".
+		// single reverse solidus character may be represented in json as "\u005C".
+		// include these in ASslice below.
+		ASslice: []string{
+			strRpt(n, "Aone"),
+			strRpt(n, "Atwo"),
+			strRpt(n, "Athree"),
+			strRpt(n, "Afour.reverse_solidus.\u005c"),
+			strRpt(n, "Afive.Gclef.\U0001d11E\"ugorji\"done.")},
+		AI64slice: []int64{
+			0, 1, -1, -22, 333, -4444, 55555, -666666,
+			// msgpack ones
+			-48, -32, -24, -8, 32, 127, 192, 255,
+			// standard ones
+			0, -1, 1,
+			math.MaxInt8, math.MaxInt8 + 4, math.MaxInt8 - 4,
+			math.MaxInt16, math.MaxInt16 + 4, math.MaxInt16 - 4,
+			math.MaxInt32, math.MaxInt32 + 4, math.MaxInt32 - 4,
+			math.MaxInt64, math.MaxInt64 - 4,
+			math.MinInt8, math.MinInt8 + 4, math.MinInt8 - 4,
+			math.MinInt16, math.MinInt16 + 4, math.MinInt16 - 4,
+			math.MinInt32, math.MinInt32 + 4, math.MinInt32 - 4,
+			math.MinInt64, math.MinInt64 + 4,
+		},
+		AUi64slice: []uint64{
+			0, 1, 22, 333, 4444, 55555, 666666,
+			// standard ones
+			math.MaxUint8, math.MaxUint8 + 4, math.MaxUint8 - 4,
+			math.MaxUint16, math.MaxUint16 + 4, math.MaxUint16 - 4,
+			math.MaxUint32, math.MaxUint32 + 4, math.MaxUint32 - 4,
+		},
+		AMSU16: map[string]uint16{strRpt(n, "1"): 1, strRpt(n, "22"): 2, strRpt(n, "333"): 3, strRpt(n, "4444"): 4},
+
+		// Note: +/- inf, NaN, and other non-representable numbers should not be explicitly tested here
+
+		AF64slice: []float64{
+			11.11e-11, -11.11e+11,
+			2.222E+12, -2.222E-12,
+			-555.55E-5, 555.55E+5,
+			666.66E-6, -666.66E+6,
+			7777.7777E-7, -7777.7777E-7,
+			-8888.8888E+8, 8888.8888E+8,
+			-99999.9999E+9, 99999.9999E+9,
+			// these below are hairy enough to need strconv.ParseFloat
+			33.33E-33, -33.33E+33,
+			44.44e+44, -44.44e-44,
+			// standard ones
+			0, -1, 1,
+			// math.Inf(1), math.Inf(-1),
+			math.Pi, math.Phi, math.E,
+			math.MaxFloat64, math.SmallestNonzeroFloat64,
+		},
+		AF32slice: []float32{
+			11.11e-11, -11.11e+11,
+			2.222E+12, -2.222E-12,
+			-555.55E-5, 555.55E+5,
+			666.66E-6, -666.66E+6,
+			7777.7777E-7, -7777.7777E-7,
+			-8888.8888E+8, 8888.8888E+8,
+			-99999.9999E+9, 99999.9999E+9,
+			// these below are hairy enough to need strconv.ParseFloat
+			33.33E-33, -33.33E+33,
+			// standard ones
+			0, -1, 1,
+			// math.Float32frombits(0x7FF00000), math.Float32frombits(0xFFF00000), //+inf and -inf
+			math.MaxFloat32, math.SmallestNonzeroFloat32,
+		},
+
+		A164slice0:  []int64{},
+		AUi64sliceN: nil,
+		AMSU16N:     nil,
+		AMSU16E:     map[string]uint16{},
+	}
+
+	if !bench {
+		a.AUi64slice = append(a.AUi64slice, math.MaxUint64, math.MaxUint64-4)
+	}
+	*ts = TestStrucCommon{
+		S: strRpt(n, `some really really cool names that are nigerian and american like "ugorji melody nwoke" - get it? `),
+
+		// set the numbers close to the limits
+		I8:   math.MaxInt8 * 2 / 3,  // 8,
+		I8n:  math.MinInt8 * 2 / 3,  // 8,
+		I16:  math.MaxInt16 * 2 / 3, // 16,
+		I16n: math.MinInt16 * 2 / 3, // 16,
+		I32:  math.MaxInt32 * 2 / 3, // 32,
+		I32n: math.MinInt32 * 2 / 3, // 32,
+		I64:  math.MaxInt64 * 2 / 3, // 64,
+		I64n: math.MinInt64 * 2 / 3, // 64,
+
+		Ui64: math.MaxUint64 * 2 / 3, // 64
+		Ui32: math.MaxUint32 * 2 / 3, // 32
+		Ui16: math.MaxUint16 * 2 / 3, // 16
+		Ui8:  math.MaxUint8 * 2 / 3,  // 8
+
+		F32: 3.402823e+38, // max representable float32 without losing precision
+		F64: 3.40281991833838838338e+53,
+
+		B:  true,
+		By: 5,
+
+		Sslice:    []string{strRpt(n, "one"), strRpt(n, "two"), strRpt(n, "three")},
 		I64slice:  []int64{1111, 2222, 3333},
 		I16slice:  []int16{44, 55, 66},
 		Ui64slice: []uint64{12121212, 34343434, 56565656},
@@ -110,45 +282,77 @@ func newTestStruc(depth int, bench bool, useInterface, useStringKeyOnly bool) (t
 		Byslice:   []byte{13, 14, 15},
 
 		Msi64: map[string]int64{
-			"one": 1,
-			"two": 2,
+			strRpt(n, "one"):       1,
+			strRpt(n, "two"):       2,
+			strRpt(n, "\"three\""): 3,
 		},
-		AnonInTestStruc: AnonInTestStruc{
-			// There's more leeway in altering this.
-			AS:    "A-String",
-			AI64:  -64646464,
-			AI16:  1616,
-			AUi64: 64646464,
-			// (U+1D11E)G-clef character may be represented in json as "\uD834\uDD1E".
-			// single reverse solidus character may be represented in json as "\u005C".
-			// include these in ASslice below.
-			ASslice: []string{"Aone", "Atwo", "Athree",
-				"Afour.reverse_solidus.\u005c", "Afive.Gclef.\U0001d11E"},
-			AI64slice: []int64{1, -22, 333, -4444, 55555, -666666},
-			AMSU16:    map[string]uint16{"1": 1, "22": 2, "333": 3, "4444": 4},
-			AF64slice: []float64{
-				11.11e-11, -11.11e+11,
-				2.222E+12, -2.222E-12,
-				-555.55E-5, 555.55E+5,
-				666.66E-6, -666.66E+6,
-				7777.7777E-7, -7777.7777E-7,
-				-8888.8888E+8, 8888.8888E+8,
-				-99999.9999E+9, 99999.9999E+9,
-				// these below are hairy enough to need strconv.ParseFloat
-				33.33E-33, -33.33E+33,
-				44.44e+44, -44.44e-44,
+
+		WrapSliceInt64:  []uint64{4, 16, 64, 256},
+		WrapSliceString: []string{strRpt(n, "4"), strRpt(n, "16"), strRpt(n, "64"), strRpt(n, "256")},
+
+		// R: Raw([]byte("goodbye")),
+		// Rext: RawExt{ 120, []byte("hello"), }, // TODO: don't set this - it's hard to test
+
+		// DecodeNaked bombs here, because the stringUint64T is decoded as a map,
+		// and a map cannot be the key type of a map.
+		// Thus, don't initialize this here.
+		// Msu2wss: map[stringUint64T]wrapStringSlice{
+		// 	{"5", 5}: []wrapString{"1", "2", "3", "4", "5"},
+		// 	{"3", 3}: []wrapString{"1", "2", "3"},
+		// },
+
+		// make Simplef same as top-level
+		// TODO: should this have slightly different values???
+		Simplef: testSimpleFields{
+			S: strRpt(n, `some really really cool names that are nigerian and american like "ugorji melody nwoke" - get it? `),
+
+			// set the numbers close to the limits
+			I8:   math.MaxInt8 * 2 / 3,  // 8,
+			I8n:  math.MinInt8 * 2 / 3,  // 8,
+			I16:  math.MaxInt16 * 2 / 3, // 16,
+			I16n: math.MinInt16 * 2 / 3, // 16,
+			I32:  math.MaxInt32 * 2 / 3, // 32,
+			I32n: math.MinInt32 * 2 / 3, // 32,
+			I64:  math.MaxInt64 * 2 / 3, // 64,
+			I64n: math.MinInt64 * 2 / 3, // 64,
+
+			Ui64: math.MaxUint64 * 2 / 3, // 64
+			Ui32: math.MaxUint32 * 2 / 3, // 32
+			Ui16: math.MaxUint16 * 2 / 3, // 16
+			Ui8:  math.MaxUint8 * 2 / 3,  // 8
+
+			F32: 3.402823e+38, // max representable float32 without losing precision
+			F64: 3.40281991833838838338e+53,
+
+			B:  true,
+			By: 5,
+
+			Sslice:    []string{strRpt(n, "one"), strRpt(n, "two"), strRpt(n, "three")},
+			I64slice:  []int64{1111, 2222, 3333},
+			I16slice:  []int16{44, 55, 66},
+			Ui64slice: []uint64{12121212, 34343434, 56565656},
+			Ui8slice:  []uint8{210, 211, 212},
+			Bslice:    []bool{true, false, true, false},
+			Byslice:   []byte{13, 14, 15},
+
+			Msi64: map[string]int64{
+				strRpt(n, "one"):       1,
+				strRpt(n, "two"):       2,
+				strRpt(n, "\"three\""): 3,
 			},
+
+			WrapSliceInt64:  []uint64{4, 16, 64, 256},
+			WrapSliceString: []string{strRpt(n, "4"), strRpt(n, "16"), strRpt(n, "64"), strRpt(n, "256")},
 		},
+
+		SstrUi64T:       []stringUint64T{{"1", 1}, {"2", 2}, {"3", 3}, {"4", 4}},
+		AnonInTestStruc: a,
+		NotAnon:         a,
 	}
-	if useInterface {
-		ts.AnonInTestStrucIntf = &AnonInTestStrucIntf{
-			Islice: []interface{}{"true", true, "no", false, uint64(288), float64(0.4)},
-			Ms: map[string]interface{}{
-				"true":     "true",
-				"int64(9)": false,
-			},
-			T: testStrucTime,
-		}
+
+	if bench {
+		ts.Ui64 = math.MaxInt64 * 2 / 3
+		ts.Simplef.Ui64 = ts.Ui64
 	}
 
 	//For benchmarks, some things will not work.
@@ -165,6 +369,11 @@ func newTestStruc(depth int, bench bool, useInterface, useStringKeyOnly bool) (t
 	if !useStringKeyOnly {
 		// ts.AnonInTestStruc.AMU32F64 = map[uint32]float64{1: 1, 2: 2, 3: 3} // Json/Bson barf
 	}
+}
+
+func newTestStruc(depth, n int, bench, useInterface, useStringKeyOnly bool) (ts *TestStruc) {
+	ts = &TestStruc{}
+	populateTestStrucCommon(&ts.TestStrucCommon, n, bench, useInterface, useStringKeyOnly)
 	if depth > 0 {
 		depth--
 		if ts.Mtsptr == nil {
@@ -173,42 +382,35 @@ func newTestStruc(depth int, bench bool, useInterface, useStringKeyOnly bool) (t
 		if ts.Mts == nil {
 			ts.Mts = make(map[string]TestStruc)
 		}
-		ts.Mtsptr["0"] = newTestStruc(depth, bench, useInterface, useStringKeyOnly)
-		ts.Mts["0"] = *(ts.Mtsptr["0"])
-		ts.Its = append(ts.Its, ts.Mtsptr["0"])
+		ts.Mtsptr[strRpt(n, "0")] = newTestStruc(depth, n, bench, useInterface, useStringKeyOnly)
+		ts.Mts[strRpt(n, "0")] = *(ts.Mtsptr[strRpt(n, "0")])
+		ts.Its = append(ts.Its, ts.Mtsptr[strRpt(n, "0")])
 	}
 	return
 }
 
-// Some other types
+var testStrRptMap = make(map[int]map[string]string)
 
-type Sstring string
-type Bbool bool
-type Sstructsmall struct {
-	A int
+func strRpt(n int, s string) string {
+	if false {
+		// fmt.Printf(">>>> calling strings.Repeat on n: %d, key: %s\n", n, s)
+		return strings.Repeat(s, n)
+	}
+	m1, ok := testStrRptMap[n]
+	if !ok {
+		// fmt.Printf(">>>> making new map for n: %v\n", n)
+		m1 = make(map[string]string)
+		testStrRptMap[n] = m1
+	}
+	v1, ok := m1[s]
+	if !ok {
+		// fmt.Printf(">>>> creating new entry for key: %s\n", s)
+		v1 = strings.Repeat(s, n)
+		m1[s] = v1
+	}
+	return v1
 }
 
-type Sstructbig struct {
-	A int
-	B bool
-	c string
-	// Sval Sstruct
-	Ssmallptr *Sstructsmall
-	Ssmall    *Sstructsmall
-	Sptr      *Sstructbig
-}
-
-type SstructbigMapBySlice struct {
-	_struct struct{} `codec:",toarray"`
-	A       int
-	B       bool
-	c       string
-	// Sval Sstruct
-	Ssmallptr *Sstructsmall
-	Ssmall    *Sstructsmall
-	Sptr      *Sstructbig
-}
-
-type Sinterface interface {
-	Noop()
-}
+// func wstrRpt(n int, s string) wrapBytes {
+// 	 return wrapBytes(bytes.Repeat([]byte(s), n))
+// }
diff --git a/vendor/github.com/ugorji/go/codec/xml.go b/vendor/github.com/ugorji/go/codec/xml.go
index 9386775d7..4fd75221f 100644
--- a/vendor/github.com/ugorji/go/codec/xml.go
+++ b/vendor/github.com/ugorji/go/codec/xml.go
@@ -24,7 +24,6 @@ It is a replacement, based on the simplicity and performance of codec.
 Look at it like JAXB for Go.
 
 Challenges:
-
   - Need to output XML preamble, with all namespaces at the right location in the output.
   - Each "end" block is dynamic, so we need to maintain a context-aware stack
   - How to decide when to use an attribute VS an element
@@ -34,24 +33,26 @@ Challenges:
 
 Extend the struct tag. See representative example:
   type X struct {
-    ID uint8 codec:"xid|http://ugorji.net/x-namespace id,omitempty,toarray,attr,cdata"
+    ID uint8 `codec:"http://ugorji.net/x-namespace xid id,omitempty,toarray,attr,cdata"`
+    // format: [namespace-uri ][namespace-prefix ]local-name, ...
   }
 
 Based on this, we encode
-  - fields as elements, BUT encode as attributes if struct tag contains ",attr".
+  - fields as elements, BUT
+    encode as attributes if struct tag contains ",attr" and is a scalar (bool, number or string)
   - text as entity-escaped text, BUT encode as CDATA if struct tag contains ",cdata".
 
-In this mode, we only encode as attribute if ",attr" is found, and only encode as CDATA
-if ",cdata" is found in the struct tag.
-
 To handle namespaces:
   - XMLHandle is denoted as being namespace-aware.
     Consequently, we WILL use the ns:name pair to encode and decode if defined, else use the plain name.
   - *Encoder and *Decoder know whether the Handle "prefers" namespaces.
   - add *Encoder.getEncName(*structFieldInfo).
     No one calls *structFieldInfo.indexForEncName directly anymore
+  - OR better yet: indexForEncName is namespace-aware, and helper.go is all namespace-aware
+    indexForEncName takes a parameter of the form namespace:local-name OR local-name
   - add *Decoder.getStructFieldInfo(encName string) // encName here is either like abc, or h1:nsabc
-    No one accesses .encName anymore except in
+    by being a method on *Decoder, or maybe a method on the Handle itself.
+    No one accesses .encName anymore
   - let encode.go and decode.go use these (for consistency)
   - only problem exists for gen.go, where we create a big switch on encName.
     Now, we also have to add a switch on strings.endsWith(kName, encNsName)
@@ -62,13 +63,14 @@ To handle namespaces:
         default {
           switch {
             case !nsAware: panic(...)
-            case strings.endsWith("nsabc"): x.abc()
+            case strings.endsWith(":abc"): x.abc()
+            case strings.endsWith(":def"): x.def()
             default: panic(...)
           }
         }
      }
 
-The structure below accomodates this:
+The structure below accommodates this:
 
   type typeInfo struct {
     sfi []*structFieldInfo // sorted by encName
@@ -88,7 +90,10 @@ indexForEncName is now an internal helper function that takes a sorted array
 (one of ti.sfins or ti.sfi). It is only used by *Encoder.getStructFieldInfo(...)
 
 There will be a separate parser from the builder.
-The parser will have a method: next() xmlToken method.
+The parser will have a method: next() xmlToken method. It has lookahead support,
+so you can pop multiple tokens, make a determination, and push them back in the order popped.
+This will be needed to determine whether we are "nakedly" decoding a container or not.
+The stack will be implemented using a slice and push/pop happens at the [0] element.
 
 xmlToken has fields:
   - type uint8: 0 | ElementStart | ElementEnd | AttrKey | AttrVal | Text
@@ -132,7 +137,7 @@ At decode time, a structure containing the following is kept
   - all internal entities (<>&"' and others written in the document)
 
 When decode starts, it parses XML namespace declarations and creates a map in the
-xmlDecDriver. While parsing, that map continously gets updated.
+xmlDecDriver. While parsing, that map continuously gets updated.
 The only problem happens when a namespace declaration happens on the node that it defines.
 e.g. <hn:name xmlns:hn="http://www.ugorji.net" >
 To handle this, each Element must be fully parsed at a time,
@@ -144,7 +149,7 @@ xmlns is a special attribute name.
   *We may decide later to allow user to use it e.g. you want to parse the xmlns mappings into a field.*
 
 Number, bool, null, mapKey, etc can all be decoded from any xmlToken.
-This accomodates map[int]string for example.
+This accommodates map[int]string for example.
 
 It should be possible to create a schema from the types,
 or vice versa (generate types from schema with appropriate tags).
@@ -178,8 +183,8 @@ An XML document is a name, a map of attributes and a list of children.
 Consequently, we cannot "DecodeNaked" into a map[string]interface{} (for example).
 We have to "DecodeNaked" into something that resembles XML data.
 
-To support DecodeNaked (decode into nil interface{}) we have to define some "supporting" types:
-    type Name struct { // Prefered. Less allocations due to conversions.
+To support DecodeNaked (decode into nil interface{}), we have to define some "supporting" types:
+    type Name struct { // Preferred. Less allocations due to conversions.
       Local string
       Space string
     }
@@ -190,6 +195,8 @@ To support DecodeNaked (decode into nil interface{}) we have to define some "sup
     }
 Only two "supporting" types are exposed for XML: Name and Element.
 
+// ------------------
+
 We considered 'type Name string' where Name is like "Space Local" (space-separated).
 We decided against it, because each creation of a name would lead to
 double allocation (first convert []byte to string, then concatenate them into a string).
@@ -215,16 +222,16 @@ intelligent accessor methods to extract information and for performance.
     }
     func (x *Element) child(i) interface{} // returns string or *Element
 
-Per XML spec and our default handling, white space is insignificant between elements,
-specifically between parent-child or siblings. White space occuring alone between start
-and end element IS significant. However, if xml:space='preserve', then we 'preserve'
-all whitespace. This is more critical when doing a DecodeNaked, but MAY not be as critical
-when decoding into a typed value.
+// ------------------
+
+Per XML spec and our default handling, white space is always treated as
+insignificant between elements, except in a text node. The xml:space='preserve'
+attribute is ignored.
 
 **Note: there is no xml: namespace. The xml: attributes were defined before namespaces.**
 **So treat them as just "directives" that should be interpreted to mean something**.
 
-On encoding, we don't add any prettifying markup (indenting, etc).
+On encoding, we support indenting aka prettifying markup in the same way we support it for json.
 
 A document or element can only be encoded/decoded from/to a struct. In this mode:
   - struct name maps to element name (or tag-info from _struct field)
@@ -258,15 +265,14 @@ the struct tag signifying it should be attr, then all its fields are encoded as
 e.g.
 
     type X struct {
-       M map[string]int `codec:"m,attr"` // encode as attributes
+       M map[string]int `codec:"m,attr"` // encode keys as attributes named
     }
 
 Question:
   - if encoding a map, what if map keys have spaces in them???
     Then they cannot be attributes or child elements. Error.
 
-Misc:
-
+Options to consider adding later:
   - For attribute values, normalize by trimming beginning and ending white space,
     and converting every white space sequence to a single space.
   - ATTLIST restrictions are enforced.
@@ -284,6 +290,8 @@ Misc:
       CheckName bool
     }
 
+Misc:
+
 ROADMAP (1 weeks):
   - build encoder (1 day)
   - build decoder (based off xmlParser) (1 day)
@@ -292,7 +300,78 @@ ROADMAP (1 weeks):
   - integrate and TEST (1 days)
   - write article and post it (1 day)
 
+// ---------- MORE NOTES FROM 2017-11-30 ------------
 
+when parsing
+- parse the attributes first
+- then parse the nodes
+
+basically:
+- if encoding a field: we use the field name for the wrapper
+- if encoding a non-field, then just use the element type name
+
+  map[string]string ==> <map><key>abc</key><value>val</value></map>... or
+                        <map key="abc">val</map>... OR
+                        <key1>val1</key1><key2>val2</key2>...                <- PREFERED
+  []string  ==> <string>v1</string><string>v2</string>...
+  string v1 ==> <string>v1</string>
+  bool true ==> <bool>true</bool>
+  float 1.0 ==> <float>1.0</float>
+  ...
+
+  F1 map[string]string ==> <F1><key>abc</key><value>val</value></F1>... OR
+                           <F1 key="abc">val</F1>... OR
+                           <F1><abc>val</abc>...</F1>                        <- PREFERED
+  F2 []string          ==> <F2>v1</F2><F2>v2</F2>...
+  F3 bool              ==> <F3>true</F3>
+  ...
+
+- a scalar is encoded as:
+  (value) of type T  ==> <T><value/></T>
+  (value) of field F ==> <F><value/></F>
+- A kv-pair is encoded as:
+  (key,value) ==> <map><key><value/></key></map> OR <map key="value">
+  (key,value) of field F ==> <F><key><value/></key></F> OR <F key="value">
+- A map or struct is just a list of kv-pairs
+- A list is encoded as sequences of same node e.g.
+  <F1 key1="value11">
+  <F1 key2="value12">
+  <F2>value21</F2>
+  <F2>value22</F2>
+- we may have to singularize the field name, when entering into xml,
+  and pluralize them when encoding.
+- bi-directional encode->decode->encode is not a MUST.
+  even encoding/xml cannot decode correctly what was encoded:
+
+  see https://play.golang.org/p/224V_nyhMS
+  func main() {
+	fmt.Println("Hello, playground")
+	v := []interface{}{"hello", 1, true, nil, time.Now()}
+	s, err := xml.Marshal(v)
+	fmt.Printf("err: %v, \ns: %s\n", err, s)
+	var v2 []interface{}
+	err = xml.Unmarshal(s, &v2)
+	fmt.Printf("err: %v, \nv2: %v\n", err, v2)
+	type T struct {
+	    V []interface{}
+	}
+	v3 := T{V: v}
+	s, err = xml.Marshal(v3)
+	fmt.Printf("err: %v, \ns: %s\n", err, s)
+	var v4 T
+	err = xml.Unmarshal(s, &v4)
+	fmt.Printf("err: %v, \nv4: %v\n", err, v4)
+  }
+  Output:
+    err: <nil>,
+    s: <string>hello</string><int>1</int><bool>true</bool><Time>2009-11-10T23:00:00Z</Time>
+    err: <nil>,
+    v2: [<nil>]
+    err: <nil>,
+    s: <T><V>hello</V><V>1</V><V>true</V><V>2009-11-10T23:00:00Z</V></T>
+    err: <nil>,
+    v4: {[<nil> <nil> <nil> <nil>]}
+-
 */
 
 // ----------- PARSER  -------------------
diff --git a/vendor/github.com/ugorji/go/codec/z_all_test.go b/vendor/github.com/ugorji/go/codec/z_all_test.go
index 364cbd7e6..d23293f0b 100644
--- a/vendor/github.com/ugorji/go/codec/z_all_test.go
+++ b/vendor/github.com/ugorji/go/codec/z_all_test.go
@@ -29,54 +29,94 @@ import "testing"
 // 	os.Exit(exitcode)
 // }
 
-func testSuite(t *testing.T, f func(t *testing.T)) {
-	// find . -name "*_test.go" | xargs grep -e 'flag.' | cut -d '&' -f 2 | cut -d ',' -f 1 | grep -e '^test'
-	// Disregard the following: testVerbose, testInitDebug, testSkipIntf, testJsonIndent (Need a test for it)
-
-	testReinit() // so flag.Parse() is called first, and never called again
-
+func testGroupResetFlags() {
 	testUseMust = false
 	testCanonical = false
 	testUseMust = false
 	testInternStr = false
-	testUseIoEncDec = false
+	testUseIoEncDec = -1
 	testStructToArray = false
-	testWriteNoSymbols = false
 	testCheckCircRef = false
-	testJsonHTMLCharsAsIs = false
 	testUseReset = false
 	testMaxInitLen = 0
-	testJsonIndent = 0
+	testUseIoWrapper = false
+	testNumRepeatString = 8
+	testEncodeOptions.RecursiveEmptyCheck = false
+	testDecodeOptions.MapValueReset = false
+	testUseIoEncDec = -1
+	testDepth = 0
+}
+
+func testSuite(t *testing.T, f func(t *testing.T)) {
+	// find . -name "*_test.go" | xargs grep -e 'flag.' | cut -d '&' -f 2 | cut -d ',' -f 1 | grep -e '^test'
+	// Disregard the following: testInitDebug, testSkipIntf, testJsonIndent (Need a test for it)
+
+	testReinit() // so flag.Parse() is called first, and never called again
+
+	testDecodeOptions = DecodeOptions{}
+	testEncodeOptions = EncodeOptions{}
+
+	testGroupResetFlags()
+
 	testReinit()
 	t.Run("optionsFalse", f)
 
-	testMaxInitLen = 10
-	testJsonIndent = 8
-	testReinit()
-	t.Run("initLen10-jsonSpaces", f)
-
-	testReinit()
-	testMaxInitLen = 10
-	testJsonIndent = -1
-	testReinit()
-	t.Run("initLen10-jsonTabs", f)
-
 	testCanonical = true
 	testUseMust = true
 	testInternStr = true
-	testUseIoEncDec = true
+	testUseIoEncDec = 0
 	testStructToArray = true
-	testWriteNoSymbols = true
 	testCheckCircRef = true
-	testJsonHTMLCharsAsIs = true
 	testUseReset = true
+	testDecodeOptions.MapValueReset = true
+	testEncodeOptions.RecursiveEmptyCheck = true
 	testReinit()
 	t.Run("optionsTrue", f)
+
+	testDepth = 6
+	testReinit()
+	t.Run("optionsTrue-deepstruct", f)
+	testDepth = 0
+
+	testEncodeOptions.AsSymbols = AsSymbolAll
+	testUseIoWrapper = true
+	testReinit()
+	t.Run("optionsTrue-ioWrapper", f)
+
+	testUseIoEncDec = -1
+
+	// make buffer small enough so that we have to re-fill multiple times.
+	testSkipRPCTests = true
+	testUseIoEncDec = 128
+	// testDecodeOptions.ReaderBufferSize = 128
+	// testEncodeOptions.WriterBufferSize = 128
+	testReinit()
+	t.Run("optionsTrue-bufio", f)
+	// testDecodeOptions.ReaderBufferSize = 0
+	// testEncodeOptions.WriterBufferSize = 0
+	testUseIoEncDec = -1
+	testSkipRPCTests = false
+
+	testNumRepeatString = 32
+	testReinit()
+	t.Run("optionsTrue-largestrings", f)
+
+	// The following here MUST be tested individually, as they create
+	// side effects i.e. the decoded value is different.
+	// testDecodeOptions.MapValueReset = true // ok - no side effects
+	// testDecodeOptions.InterfaceReset = true // error??? because we do deepEquals to verify
+	// testDecodeOptions.ErrorIfNoField = true // error, as expected, as fields not there
+	// testDecodeOptions.ErrorIfNoArrayExpand = true // no error, but no error case either
+	// testDecodeOptions.PreferArrayOverSlice = true // error??? because slice != array.
+	// .... however, update deepEqual to take this option
+	// testReinit()
+	// t.Run("optionsTrue-resetOptions", f)
+
+	testGroupResetFlags()
 }
 
 /*
-z='codec_test.go'
-find . -name "$z" | xargs grep -e '^func Test' | \
+find . -name "codec_test.go" | xargs grep -e '^func Test' | \
     cut -d '(' -f 1 | cut -d ' ' -f 2 | \
     while read f; do echo "t.Run(\"$f\", $f)"; done
 */
@@ -84,6 +124,7 @@ find . -name "$z" | xargs grep -e '^func Test' | \
 func testCodecGroup(t *testing.T) {
 	// println("running testcodecsuite")
 	// <setup code>
+
 	t.Run("TestBincCodecsTable", TestBincCodecsTable)
 	t.Run("TestBincCodecsMisc", TestBincCodecsMisc)
 	t.Run("TestBincCodecsEmbeddedPointer", TestBincCodecsEmbeddedPointer)
@@ -129,7 +170,297 @@ func testCodecGroup(t *testing.T) {
 	t.Run("TestJsonLargeInteger", TestJsonLargeInteger)
 	t.Run("TestJsonDecodeNonStringScalarInStringContext", TestJsonDecodeNonStringScalarInStringContext)
 	t.Run("TestJsonEncodeIndent", TestJsonEncodeIndent)
+
+	t.Run("TestJsonSwallowAndZero", TestJsonSwallowAndZero)
+	t.Run("TestCborSwallowAndZero", TestCborSwallowAndZero)
+	t.Run("TestMsgpackSwallowAndZero", TestMsgpackSwallowAndZero)
+	t.Run("TestBincSwallowAndZero", TestBincSwallowAndZero)
+	t.Run("TestSimpleSwallowAndZero", TestSimpleSwallowAndZero)
+	t.Run("TestJsonRawExt", TestJsonRawExt)
+	t.Run("TestCborRawExt", TestCborRawExt)
+	t.Run("TestMsgpackRawExt", TestMsgpackRawExt)
+	t.Run("TestBincRawExt", TestBincRawExt)
+	t.Run("TestSimpleRawExt", TestSimpleRawExt)
+	t.Run("TestJsonMapStructKey", TestJsonMapStructKey)
+	t.Run("TestCborMapStructKey", TestCborMapStructKey)
+	t.Run("TestMsgpackMapStructKey", TestMsgpackMapStructKey)
+	t.Run("TestBincMapStructKey", TestBincMapStructKey)
+	t.Run("TestSimpleMapStructKey", TestSimpleMapStructKey)
+	t.Run("TestJsonDecodeNilMapValue", TestJsonDecodeNilMapValue)
+	t.Run("TestCborDecodeNilMapValue", TestCborDecodeNilMapValue)
+	t.Run("TestMsgpackDecodeNilMapValue", TestMsgpackDecodeNilMapValue)
+	t.Run("TestBincDecodeNilMapValue", TestBincDecodeNilMapValue)
+	t.Run("TestSimpleDecodeNilMapValue", TestSimpleDecodeNilMapValue)
+	t.Run("TestJsonEmbeddedFieldPrecedence", TestJsonEmbeddedFieldPrecedence)
+	t.Run("TestCborEmbeddedFieldPrecedence", TestCborEmbeddedFieldPrecedence)
+	t.Run("TestMsgpackEmbeddedFieldPrecedence", TestMsgpackEmbeddedFieldPrecedence)
+	t.Run("TestBincEmbeddedFieldPrecedence", TestBincEmbeddedFieldPrecedence)
+	t.Run("TestSimpleEmbeddedFieldPrecedence", TestSimpleEmbeddedFieldPrecedence)
+	t.Run("TestJsonLargeContainerLen", TestJsonLargeContainerLen)
+	t.Run("TestCborLargeContainerLen", TestCborLargeContainerLen)
+	t.Run("TestMsgpackLargeContainerLen", TestMsgpackLargeContainerLen)
+	t.Run("TestBincLargeContainerLen", TestBincLargeContainerLen)
+	t.Run("TestSimpleLargeContainerLen", TestSimpleLargeContainerLen)
+	t.Run("TestJsonMammothMapsAndSlices", TestJsonMammothMapsAndSlices)
+	t.Run("TestCborMammothMapsAndSlices", TestCborMammothMapsAndSlices)
+	t.Run("TestMsgpackMammothMapsAndSlices", TestMsgpackMammothMapsAndSlices)
+	t.Run("TestBincMammothMapsAndSlices", TestBincMammothMapsAndSlices)
+	t.Run("TestSimpleMammothMapsAndSlices", TestSimpleMammothMapsAndSlices)
+	t.Run("TestJsonTime", TestJsonTime)
+	t.Run("TestCborTime", TestCborTime)
+	t.Run("TestMsgpackTime", TestMsgpackTime)
+	t.Run("TestBincTime", TestBincTime)
+	t.Run("TestSimpleTime", TestSimpleTime)
+	t.Run("TestJsonUintToInt", TestJsonUintToInt)
+	t.Run("TestCborUintToInt", TestCborUintToInt)
+	t.Run("TestMsgpackUintToInt", TestMsgpackUintToInt)
+	t.Run("TestBincUintToInt", TestBincUintToInt)
+	t.Run("TestSimpleUintToInt", TestSimpleUintToInt)
+	t.Run("TestJsonDifferentMapOrSliceType", TestJsonDifferentMapOrSliceType)
+	t.Run("TestCborDifferentMapOrSliceType", TestCborDifferentMapOrSliceType)
+	t.Run("TestMsgpackDifferentMapOrSliceType", TestMsgpackDifferentMapOrSliceType)
+	t.Run("TestBincDifferentMapOrSliceType", TestBincDifferentMapOrSliceType)
+	t.Run("TestSimpleDifferentMapOrSliceType", TestSimpleDifferentMapOrSliceType)
+	t.Run("TestJsonScalars", TestJsonScalars)
+	t.Run("TestCborScalars", TestCborScalars)
+	t.Run("TestMsgpackScalars", TestMsgpackScalars)
+	t.Run("TestBincScalars", TestBincScalars)
+	t.Run("TestSimpleScalars", TestSimpleScalars)
+
+	t.Run("TestJsonInvalidUnicode", TestJsonInvalidUnicode)
+	t.Run("TestCborHalfFloat", TestCborHalfFloat)
 	// <tear-down code>
 }
 
-func TestCodecSuite(t *testing.T) { testSuite(t, testCodecGroup) }
+func testJsonGroup(t *testing.T) {
+	t.Run("TestJsonCodecsTable", TestJsonCodecsTable)
+	t.Run("TestJsonCodecsMisc", TestJsonCodecsMisc)
+	t.Run("TestJsonCodecsEmbeddedPointer", TestJsonCodecsEmbeddedPointer)
+	t.Run("TestJsonCodecChan", TestJsonCodecChan)
+	t.Run("TestJsonStdEncIntf", TestJsonStdEncIntf)
+	t.Run("TestJsonMammoth", TestJsonMammoth)
+	t.Run("TestJsonRaw", TestJsonRaw)
+	t.Run("TestJsonRpcGo", TestJsonRpcGo)
+	t.Run("TestJsonLargeInteger", TestJsonLargeInteger)
+	t.Run("TestJsonDecodeNonStringScalarInStringContext", TestJsonDecodeNonStringScalarInStringContext)
+	t.Run("TestJsonEncodeIndent", TestJsonEncodeIndent)
+
+	t.Run("TestJsonSwallowAndZero", TestJsonSwallowAndZero)
+	t.Run("TestJsonRawExt", TestJsonRawExt)
+	t.Run("TestJsonMapStructKey", TestJsonMapStructKey)
+	t.Run("TestJsonDecodeNilMapValue", TestJsonDecodeNilMapValue)
+	t.Run("TestJsonEmbeddedFieldPrecedence", TestJsonEmbeddedFieldPrecedence)
+	t.Run("TestJsonLargeContainerLen", TestJsonLargeContainerLen)
+	t.Run("TestJsonMammothMapsAndSlices", TestJsonMammothMapsAndSlices)
+	t.Run("TestJsonInvalidUnicode", TestJsonInvalidUnicode)
+	t.Run("TestJsonTime", TestJsonTime)
+	t.Run("TestJsonUintToInt", TestJsonUintToInt)
+	t.Run("TestJsonDifferentMapOrSliceType", TestJsonDifferentMapOrSliceType)
+	t.Run("TestJsonScalars", TestJsonScalars)
+}
+
+func testBincGroup(t *testing.T) {
+	t.Run("TestBincCodecsTable", TestBincCodecsTable)
+	t.Run("TestBincCodecsMisc", TestBincCodecsMisc)
+	t.Run("TestBincCodecsEmbeddedPointer", TestBincCodecsEmbeddedPointer)
+	t.Run("TestBincStdEncIntf", TestBincStdEncIntf)
+	t.Run("TestBincMammoth", TestBincMammoth)
+	t.Run("TestBincRaw", TestBincRaw)
+	t.Run("TestSimpleRpcGo", TestSimpleRpcGo)
+	t.Run("TestBincUnderlyingType", TestBincUnderlyingType)
+
+	t.Run("TestBincSwallowAndZero", TestBincSwallowAndZero)
+	t.Run("TestBincRawExt", TestBincRawExt)
+	t.Run("TestBincMapStructKey", TestBincMapStructKey)
+	t.Run("TestBincDecodeNilMapValue", TestBincDecodeNilMapValue)
+	t.Run("TestBincEmbeddedFieldPrecedence", TestBincEmbeddedFieldPrecedence)
+	t.Run("TestBincLargeContainerLen", TestBincLargeContainerLen)
+	t.Run("TestBincMammothMapsAndSlices", TestBincMammothMapsAndSlices)
+	t.Run("TestBincTime", TestBincTime)
+	t.Run("TestBincUintToInt", TestBincUintToInt)
+	t.Run("TestBincDifferentMapOrSliceType", TestBincDifferentMapOrSliceType)
+	t.Run("TestBincScalars", TestBincScalars)
+}
+
+func testCborGroup(t *testing.T) {
+	t.Run("TestCborCodecsTable", TestCborCodecsTable)
+	t.Run("TestCborCodecsMisc", TestCborCodecsMisc)
+	t.Run("TestCborCodecsEmbeddedPointer", TestCborCodecsEmbeddedPointer)
+	t.Run("TestCborMapEncodeForCanonical", TestCborMapEncodeForCanonical)
+	t.Run("TestCborCodecChan", TestCborCodecChan)
+	t.Run("TestCborStdEncIntf", TestCborStdEncIntf)
+	t.Run("TestCborMammoth", TestCborMammoth)
+	t.Run("TestCborRaw", TestCborRaw)
+	t.Run("TestCborRpcGo", TestCborRpcGo)
+
+	t.Run("TestCborSwallowAndZero", TestCborSwallowAndZero)
+	t.Run("TestCborRawExt", TestCborRawExt)
+	t.Run("TestCborMapStructKey", TestCborMapStructKey)
+	t.Run("TestCborDecodeNilMapValue", TestCborDecodeNilMapValue)
+	t.Run("TestCborEmbeddedFieldPrecedence", TestCborEmbeddedFieldPrecedence)
+	t.Run("TestCborLargeContainerLen", TestCborLargeContainerLen)
+	t.Run("TestCborMammothMapsAndSlices", TestCborMammothMapsAndSlices)
+	t.Run("TestCborTime", TestCborTime)
+	t.Run("TestCborUintToInt", TestCborUintToInt)
+	t.Run("TestCborDifferentMapOrSliceType", TestCborDifferentMapOrSliceType)
+	t.Run("TestCborScalars", TestCborScalars)
+
+	t.Run("TestCborHalfFloat", TestCborHalfFloat)
+}
+
+func testMsgpackGroup(t *testing.T) {
+	t.Run("TestMsgpackCodecsTable", TestMsgpackCodecsTable)
+	t.Run("TestMsgpackCodecsMisc", TestMsgpackCodecsMisc)
+	t.Run("TestMsgpackCodecsEmbeddedPointer", TestMsgpackCodecsEmbeddedPointer)
+	t.Run("TestMsgpackStdEncIntf", TestMsgpackStdEncIntf)
+	t.Run("TestMsgpackMammoth", TestMsgpackMammoth)
+	t.Run("TestMsgpackRaw", TestMsgpackRaw)
+	t.Run("TestMsgpackRpcGo", TestMsgpackRpcGo)
+	t.Run("TestMsgpackRpcSpec", TestMsgpackRpcSpec)
+	t.Run("TestMsgpackSwallowAndZero", TestMsgpackSwallowAndZero)
+	t.Run("TestMsgpackRawExt", TestMsgpackRawExt)
+	t.Run("TestMsgpackMapStructKey", TestMsgpackMapStructKey)
+	t.Run("TestMsgpackDecodeNilMapValue", TestMsgpackDecodeNilMapValue)
+	t.Run("TestMsgpackEmbeddedFieldPrecedence", TestMsgpackEmbeddedFieldPrecedence)
+	t.Run("TestMsgpackLargeContainerLen", TestMsgpackLargeContainerLen)
+	t.Run("TestMsgpackMammothMapsAndSlices", TestMsgpackMammothMapsAndSlices)
+	t.Run("TestMsgpackTime", TestMsgpackTime)
+	t.Run("TestMsgpackUintToInt", TestMsgpackUintToInt)
+	t.Run("TestMsgpackDifferentMapOrSliceType", TestMsgpackDifferentMapOrSliceType)
+	t.Run("TestMsgpackScalars", TestMsgpackScalars)
+}
+
+func testSimpleGroup(t *testing.T) {
+	t.Run("TestSimpleCodecsTable", TestSimpleCodecsTable)
+	t.Run("TestSimpleCodecsMisc", TestSimpleCodecsMisc)
+	t.Run("TestSimpleCodecsEmbeddedPointer", TestSimpleCodecsEmbeddedPointer)
+	t.Run("TestSimpleStdEncIntf", TestSimpleStdEncIntf)
+	t.Run("TestSimpleMammoth", TestSimpleMammoth)
+	t.Run("TestSimpleRaw", TestSimpleRaw)
+	t.Run("TestSimpleRpcGo", TestSimpleRpcGo)
+	t.Run("TestSimpleSwallowAndZero", TestSimpleSwallowAndZero)
+	t.Run("TestSimpleRawExt", TestSimpleRawExt)
+	t.Run("TestSimpleMapStructKey", TestSimpleMapStructKey)
+	t.Run("TestSimpleDecodeNilMapValue", TestSimpleDecodeNilMapValue)
+	t.Run("TestSimpleEmbeddedFieldPrecedence", TestSimpleEmbeddedFieldPrecedence)
+	t.Run("TestSimpleLargeContainerLen", TestSimpleLargeContainerLen)
+	t.Run("TestSimpleMammothMapsAndSlices", TestSimpleMammothMapsAndSlices)
+	t.Run("TestSimpleTime", TestSimpleTime)
+	t.Run("TestSimpleUintToInt", TestSimpleUintToInt)
+	t.Run("TestSimpleDifferentMapOrSliceType", TestSimpleDifferentMapOrSliceType)
+	t.Run("TestSimpleScalars", TestSimpleScalars)
+}
+
+func testSimpleMammothGroup(t *testing.T) {
+	t.Run("TestSimpleMammothMapsAndSlices", TestSimpleMammothMapsAndSlices)
+}
+
+func testRpcGroup(t *testing.T) {
+	t.Run("TestBincRpcGo", TestBincRpcGo)
+	t.Run("TestSimpleRpcGo", TestSimpleRpcGo)
+	t.Run("TestMsgpackRpcGo", TestMsgpackRpcGo)
+	t.Run("TestCborRpcGo", TestCborRpcGo)
+	t.Run("TestJsonRpcGo", TestJsonRpcGo)
+	t.Run("TestMsgpackRpcSpec", TestMsgpackRpcSpec)
+}
+
+func TestCodecSuite(t *testing.T) {
+	testSuite(t, testCodecGroup)
+
+	testGroupResetFlags()
+
+	oldIndent, oldCharsAsis, oldPreferFloat, oldMapKeyAsString :=
+		testJsonH.Indent, testJsonH.HTMLCharsAsIs, testJsonH.PreferFloat, testJsonH.MapKeyAsString
+
+	testMaxInitLen = 10
+	testJsonH.Indent = 8
+	testJsonH.HTMLCharsAsIs = true
+	testJsonH.MapKeyAsString = true
+	// testJsonH.PreferFloat = true
+	testReinit()
+	t.Run("json-spaces-htmlcharsasis-initLen10", testJsonGroup)
+
+	testMaxInitLen = 10
+	testJsonH.Indent = -1
+	testJsonH.HTMLCharsAsIs = false
+	testJsonH.MapKeyAsString = true
+	// testJsonH.PreferFloat = false
+	testReinit()
+	t.Run("json-tabs-initLen10", testJsonGroup)
+
+	testJsonH.Indent, testJsonH.HTMLCharsAsIs, testJsonH.PreferFloat, testJsonH.MapKeyAsString =
+		oldIndent, oldCharsAsis, oldPreferFloat, oldMapKeyAsString
+
+	oldIndefLen := testCborH.IndefiniteLength
+
+	testCborH.IndefiniteLength = true
+	testReinit()
+	t.Run("cbor-indefinitelength", testCborGroup)
+
+	testCborH.IndefiniteLength = oldIndefLen
+
+	oldTimeRFC3339 := testCborH.TimeRFC3339
+	testCborH.TimeRFC3339 = !testCborH.TimeRFC3339
+	testReinit()
+	t.Run("cbor-rfc3339", testCborGroup)
+	testCborH.TimeRFC3339 = oldTimeRFC3339
+
+	oldSymbols := testBincH.getBasicHandle().AsSymbols
+
+	testBincH.getBasicHandle().AsSymbols = AsSymbolNone
+	testReinit()
+	t.Run("binc-no-symbols", testBincGroup)
+
+	testBincH.getBasicHandle().AsSymbols = AsSymbolAll
+	testReinit()
+	t.Run("binc-all-symbols", testBincGroup)
+
+	testBincH.getBasicHandle().AsSymbols = oldSymbols
+
+	oldWriteExt := testMsgpackH.WriteExt
+	oldNoFixedNum := testMsgpackH.NoFixedNum
+
+	testMsgpackH.WriteExt = !testMsgpackH.WriteExt
+	testReinit()
+	t.Run("msgpack-inverse-writeext", testMsgpackGroup)
+
+	testMsgpackH.WriteExt = oldWriteExt
+
+	testMsgpackH.NoFixedNum = !testMsgpackH.NoFixedNum
+	testReinit()
+	t.Run("msgpack-fixednum", testMsgpackGroup)
+
+	testMsgpackH.NoFixedNum = oldNoFixedNum
+
+	oldEncZeroValuesAsNil := testSimpleH.EncZeroValuesAsNil
+	testSimpleH.EncZeroValuesAsNil = !testSimpleH.EncZeroValuesAsNil
+	testUseMust = true
+	testReinit()
+	t.Run("simple-enczeroasnil", testSimpleMammothGroup) // testSimpleGroup
+	testSimpleH.EncZeroValuesAsNil = oldEncZeroValuesAsNil
+
+	oldRpcBufsize := testRpcBufsize
+	testRpcBufsize = 0
+	t.Run("rpc-buf-0", testRpcGroup)
+	testRpcBufsize = 0
+	t.Run("rpc-buf-00", testRpcGroup)
+	testRpcBufsize = 0
+	t.Run("rpc-buf-000", testRpcGroup)
+	testRpcBufsize = 16
+	t.Run("rpc-buf-16", testRpcGroup)
+	testRpcBufsize = 2048
+	t.Run("rpc-buf-2048", testRpcGroup)
+	testRpcBufsize = oldRpcBufsize
+
+	testGroupResetFlags()
+}
+
+// func TestCodecSuite(t *testing.T) {
+// 	testReinit() // so flag.Parse() is called first, and never called again
+// 	testDecodeOptions, testEncodeOptions = DecodeOptions{}, EncodeOptions{}
+// 	testGroupResetFlags()
+// 	testReinit()
+// 	t.Run("optionsFalse", func(t *testing.T) {
+// 		t.Run("TestJsonMammothMapsAndSlices", TestJsonMammothMapsAndSlices)
+// 	})
+// }
diff --git a/vendor/manifest b/vendor/manifest
index 135dc2cb1..710ad37f3 100644
--- a/vendor/manifest
+++ b/vendor/manifest
@@ -964,8 +964,8 @@
 		{
 			"importpath": "github.com/ugorji/go/codec",
 			"repository": "https://github.com/ugorji/go",
-			"vcs": "",
-			"revision": "c062049c1793b01a3cc3fe786108edabbaf7756b",
+			"vcs": "git",
+			"revision": "f57d8945648dbfe4c332cff9c50fb57548958e3f",
 			"branch": "master",
 			"path": "/codec"
 		},