[chore] remove vendor

1 files changed, 0 insertions, 8046 deletions

diff --git a/vendor/github.com/ugorji/go/codec/msgpack.mono.generated.go b/vendor/github.com/ugorji/go/codec/msgpack.mono.generated.go
deleted file mode 100644
index ff2fe4af9..000000000
--- a/vendor/github.com/ugorji/go/codec/msgpack.mono.generated.go
+++ /dev/null
@@ -1,8046 +0,0 @@
-//go:build !notmono && !codec.notmono 
-
-// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
-// Use of this source code is governed by a MIT license found in the LICENSE file.
-
-package codec
-
-import (
-	"encoding"
-
-	"io"
-	"math"
-	"reflect"
-	"slices"
-	"sort"
-	"strconv"
-	"sync"
-	"time"
-	"unicode/utf8"
-)
-
-type helperEncDriverMsgpackBytes struct{}
-type encFnMsgpackBytes struct {
-	i  encFnInfo
-	fe func(*encoderMsgpackBytes, *encFnInfo, reflect.Value)
-}
-type encRtidFnMsgpackBytes struct {
-	rtid uintptr
-	fn   *encFnMsgpackBytes
-}
-type encoderMsgpackBytes struct {
-	dh helperEncDriverMsgpackBytes
-	fp *fastpathEsMsgpackBytes
-	e  msgpackEncDriverBytes
-	encoderBase
-}
-type helperDecDriverMsgpackBytes struct{}
-type decFnMsgpackBytes struct {
-	i  decFnInfo
-	fd func(*decoderMsgpackBytes, *decFnInfo, reflect.Value)
-}
-type decRtidFnMsgpackBytes struct {
-	rtid uintptr
-	fn   *decFnMsgpackBytes
-}
-type decoderMsgpackBytes struct {
-	dh helperDecDriverMsgpackBytes
-	fp *fastpathDsMsgpackBytes
-	d  msgpackDecDriverBytes
-	decoderBase
-}
-type msgpackEncDriverBytes struct {
-	noBuiltInTypes
-	encDriverNoopContainerWriter
-	encDriverNoState
-	encDriverContainerNoTrackerT
-	encInit2er
-
-	h *MsgpackHandle
-	e *encoderBase
-	w bytesEncAppender
-}
-type msgpackDecDriverBytes struct {
-	decDriverNoopContainerReader
-	decDriverNoopNumberHelper
-	decInit2er
-
-	h *MsgpackHandle
-	d *decoderBase
-	r bytesDecReader
-
-	bdAndBdread
-
-	noBuiltInTypes
-}
-
-func (e *encoderMsgpackBytes) rawExt(_ *encFnInfo, rv reflect.Value) {
-	if re := rv2i(rv).(*RawExt); re == nil {
-		e.e.EncodeNil()
-	} else {
-		e.e.EncodeRawExt(re)
-	}
-}
-
-func (e *encoderMsgpackBytes) ext(f *encFnInfo, rv reflect.Value) {
-	e.e.EncodeExt(rv2i(rv), f.ti.rt, f.xfTag, f.xfFn)
-}
-
-func (e *encoderMsgpackBytes) selferMarshal(_ *encFnInfo, rv reflect.Value) {
-	rv2i(rv).(Selfer).CodecEncodeSelf(&Encoder{e})
-}
-
-func (e *encoderMsgpackBytes) binaryMarshal(_ *encFnInfo, rv reflect.Value) {
-	bs, fnerr := rv2i(rv).(encoding.BinaryMarshaler).MarshalBinary()
-	e.marshalRaw(bs, fnerr)
-}
-
-func (e *encoderMsgpackBytes) textMarshal(_ *encFnInfo, rv reflect.Value) {
-	bs, fnerr := rv2i(rv).(encoding.TextMarshaler).MarshalText()
-	e.marshalUtf8(bs, fnerr)
-}
-
-func (e *encoderMsgpackBytes) jsonMarshal(_ *encFnInfo, rv reflect.Value) {
-	bs, fnerr := rv2i(rv).(jsonMarshaler).MarshalJSON()
-	e.marshalAsis(bs, fnerr)
-}
-
-func (e *encoderMsgpackBytes) raw(_ *encFnInfo, rv reflect.Value) {
-	e.rawBytes(rv2i(rv).(Raw))
-}
-
-func (e *encoderMsgpackBytes) encodeComplex64(v complex64) {
-	if imag(v) != 0 {
-		halt.errorf("cannot encode complex number: %v, with imaginary values: %v", any(v), any(imag(v)))
-	}
-	e.e.EncodeFloat32(real(v))
-}
-
-func (e *encoderMsgpackBytes) encodeComplex128(v complex128) {
-	if imag(v) != 0 {
-		halt.errorf("cannot encode complex number: %v, with imaginary values: %v", any(v), any(imag(v)))
-	}
-	e.e.EncodeFloat64(real(v))
-}
-
-func (e *encoderMsgpackBytes) kBool(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeBool(rvGetBool(rv))
-}
-
-func (e *encoderMsgpackBytes) kTime(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeTime(rvGetTime(rv))
-}
-
-func (e *encoderMsgpackBytes) kString(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeString(rvGetString(rv))
-}
-
-func (e *encoderMsgpackBytes) kFloat32(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeFloat32(rvGetFloat32(rv))
-}
-
-func (e *encoderMsgpackBytes) kFloat64(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeFloat64(rvGetFloat64(rv))
-}
-
-func (e *encoderMsgpackBytes) kComplex64(_ *encFnInfo, rv reflect.Value) {
-	e.encodeComplex64(rvGetComplex64(rv))
-}
-
-func (e *encoderMsgpackBytes) kComplex128(_ *encFnInfo, rv reflect.Value) {
-	e.encodeComplex128(rvGetComplex128(rv))
-}
-
-func (e *encoderMsgpackBytes) kInt(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeInt(int64(rvGetInt(rv)))
-}
-
-func (e *encoderMsgpackBytes) kInt8(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeInt(int64(rvGetInt8(rv)))
-}
-
-func (e *encoderMsgpackBytes) kInt16(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeInt(int64(rvGetInt16(rv)))
-}
-
-func (e *encoderMsgpackBytes) kInt32(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeInt(int64(rvGetInt32(rv)))
-}
-
-func (e *encoderMsgpackBytes) kInt64(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeInt(int64(rvGetInt64(rv)))
-}
-
-func (e *encoderMsgpackBytes) kUint(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeUint(uint64(rvGetUint(rv)))
-}
-
-func (e *encoderMsgpackBytes) kUint8(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeUint(uint64(rvGetUint8(rv)))
-}
-
-func (e *encoderMsgpackBytes) kUint16(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeUint(uint64(rvGetUint16(rv)))
-}
-
-func (e *encoderMsgpackBytes) kUint32(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeUint(uint64(rvGetUint32(rv)))
-}
-
-func (e *encoderMsgpackBytes) kUint64(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeUint(uint64(rvGetUint64(rv)))
-}
-
-func (e *encoderMsgpackBytes) kUintptr(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeUint(uint64(rvGetUintptr(rv)))
-}
-
-func (e *encoderMsgpackBytes) kSeqFn(rt reflect.Type) (fn *encFnMsgpackBytes) {
-
-	if rt = baseRT(rt); rt.Kind() != reflect.Interface {
-		fn = e.fn(rt)
-	}
-	return
-}
-
-func (e *encoderMsgpackBytes) kArrayWMbs(rv reflect.Value, ti *typeInfo, isSlice bool) {
-	var l int
-	if isSlice {
-		l = rvLenSlice(rv)
-	} else {
-		l = rv.Len()
-	}
-	if l == 0 {
-		e.e.WriteMapEmpty()
-		return
-	}
-	e.haltOnMbsOddLen(l)
-	e.mapStart(l >> 1)
-
-	var fn *encFnMsgpackBytes
-	builtin := ti.tielem.flagEncBuiltin
-	if !builtin {
-		fn = e.kSeqFn(ti.elem)
-	}
-
-	j := 0
-	e.c = containerMapKey
-	e.e.WriteMapElemKey(true)
-	for {
-		rvv := rvArrayIndex(rv, j, ti, isSlice)
-		if builtin {
-			e.encodeIB(rv2i(baseRVRV(rvv)))
-		} else {
-			e.encodeValue(rvv, fn)
-		}
-		j++
-		if j == l {
-			break
-		}
-		if j&1 == 0 {
-			e.c = containerMapKey
-			e.e.WriteMapElemKey(false)
-		} else {
-			e.mapElemValue()
-		}
-	}
-	e.c = 0
-	e.e.WriteMapEnd()
-
-}
-
-func (e *encoderMsgpackBytes) kArrayW(rv reflect.Value, ti *typeInfo, isSlice bool) {
-	var l int
-	if isSlice {
-		l = rvLenSlice(rv)
-	} else {
-		l = rv.Len()
-	}
-	if l <= 0 {
-		e.e.WriteArrayEmpty()
-		return
-	}
-	e.arrayStart(l)
-
-	var fn *encFnMsgpackBytes
-	if !ti.tielem.flagEncBuiltin {
-		fn = e.kSeqFn(ti.elem)
-	}
-
-	j := 0
-	e.c = containerArrayElem
-	e.e.WriteArrayElem(true)
-	builtin := ti.tielem.flagEncBuiltin
-	for {
-		rvv := rvArrayIndex(rv, j, ti, isSlice)
-		if builtin {
-			e.encodeIB(rv2i(baseRVRV(rvv)))
-		} else {
-			e.encodeValue(rvv, fn)
-		}
-		j++
-		if j == l {
-			break
-		}
-		e.c = containerArrayElem
-		e.e.WriteArrayElem(false)
-	}
-
-	e.c = 0
-	e.e.WriteArrayEnd()
-}
-
-func (e *encoderMsgpackBytes) kChan(f *encFnInfo, rv reflect.Value) {
-	if f.ti.chandir&uint8(reflect.RecvDir) == 0 {
-		halt.errorStr("send-only channel cannot be encoded")
-	}
-	if !f.ti.mbs && uint8TypId == rt2id(f.ti.elem) {
-		e.kSliceBytesChan(rv)
-		return
-	}
-	rtslice := reflect.SliceOf(f.ti.elem)
-	rv = chanToSlice(rv, rtslice, e.h.ChanRecvTimeout)
-	ti := e.h.getTypeInfo(rt2id(rtslice), rtslice)
-	if f.ti.mbs {
-		e.kArrayWMbs(rv, ti, true)
-	} else {
-		e.kArrayW(rv, ti, true)
-	}
-}
-
-func (e *encoderMsgpackBytes) kSlice(f *encFnInfo, rv reflect.Value) {
-	if f.ti.mbs {
-		e.kArrayWMbs(rv, f.ti, true)
-	} else if f.ti.rtid == uint8SliceTypId || uint8TypId == rt2id(f.ti.elem) {
-
-		e.e.EncodeBytes(rvGetBytes(rv))
-	} else {
-		e.kArrayW(rv, f.ti, true)
-	}
-}
-
-func (e *encoderMsgpackBytes) kArray(f *encFnInfo, rv reflect.Value) {
-	if f.ti.mbs {
-		e.kArrayWMbs(rv, f.ti, false)
-	} else if handleBytesWithinKArray && uint8TypId == rt2id(f.ti.elem) {
-		e.e.EncodeStringBytesRaw(rvGetArrayBytes(rv, nil))
-	} else {
-		e.kArrayW(rv, f.ti, false)
-	}
-}
-
-func (e *encoderMsgpackBytes) kSliceBytesChan(rv reflect.Value) {
-
-	bs0 := e.blist.peek(32, true)
-	bs := bs0
-
-	irv := rv2i(rv)
-	ch, ok := irv.(<-chan byte)
-	if !ok {
-		ch = irv.(chan byte)
-	}
-
-L1:
-	switch timeout := e.h.ChanRecvTimeout; {
-	case timeout == 0:
-		for {
-			select {
-			case b := <-ch:
-				bs = append(bs, b)
-			default:
-				break L1
-			}
-		}
-	case timeout > 0:
-		tt := time.NewTimer(timeout)
-		for {
-			select {
-			case b := <-ch:
-				bs = append(bs, b)
-			case <-tt.C:
-
-				break L1
-			}
-		}
-	default:
-		for b := range ch {
-			bs = append(bs, b)
-		}
-	}
-
-	e.e.EncodeBytes(bs)
-	e.blist.put(bs)
-	if !byteSliceSameData(bs0, bs) {
-		e.blist.put(bs0)
-	}
-}
-
-func (e *encoderMsgpackBytes) kStructFieldKey(keyType valueType, encName string) {
-
-	if keyType == valueTypeString {
-		e.e.EncodeString(encName)
-	} else if keyType == valueTypeInt {
-		e.e.EncodeInt(must.Int(strconv.ParseInt(encName, 10, 64)))
-	} else if keyType == valueTypeUint {
-		e.e.EncodeUint(must.Uint(strconv.ParseUint(encName, 10, 64)))
-	} else if keyType == valueTypeFloat {
-		e.e.EncodeFloat64(must.Float(strconv.ParseFloat(encName, 64)))
-	} else {
-		halt.errorStr2("invalid struct key type: ", keyType.String())
-	}
-
-}
-
-func (e *encoderMsgpackBytes) kStructSimple(f *encFnInfo, rv reflect.Value) {
-	_ = e.e
-	tisfi := f.ti.sfi.source()
-
-	chkCirRef := e.h.CheckCircularRef
-	var si *structFieldInfo
-	var j int
-
-	if f.ti.toArray || e.h.StructToArray {
-		if len(tisfi) == 0 {
-			e.e.WriteArrayEmpty()
-			return
-		}
-		e.arrayStart(len(tisfi))
-		for j, si = range tisfi {
-			e.c = containerArrayElem
-			e.e.WriteArrayElem(j == 0)
-			if si.encBuiltin {
-				e.encodeIB(rv2i(si.fieldNoAlloc(rv, true)))
-			} else {
-				e.encodeValue(si.fieldNoAlloc(rv, !chkCirRef), nil)
-			}
-		}
-		e.c = 0
-		e.e.WriteArrayEnd()
-	} else {
-		if len(tisfi) == 0 {
-			e.e.WriteMapEmpty()
-			return
-		}
-		if e.h.Canonical {
-			tisfi = f.ti.sfi.sorted()
-		}
-		e.mapStart(len(tisfi))
-		for j, si = range tisfi {
-			e.c = containerMapKey
-			e.e.WriteMapElemKey(j == 0)
-			e.e.EncodeStringNoEscape4Json(si.encName)
-			e.mapElemValue()
-			if si.encBuiltin {
-				e.encodeIB(rv2i(si.fieldNoAlloc(rv, true)))
-			} else {
-				e.encodeValue(si.fieldNoAlloc(rv, !chkCirRef), nil)
-			}
-		}
-		e.c = 0
-		e.e.WriteMapEnd()
-	}
-}
-
-func (e *encoderMsgpackBytes) kStruct(f *encFnInfo, rv reflect.Value) {
-	_ = e.e
-	ti := f.ti
-	toMap := !(ti.toArray || e.h.StructToArray)
-	var mf map[string]interface{}
-	if ti.flagMissingFielder {
-		toMap = true
-		mf = rv2i(rv).(MissingFielder).CodecMissingFields()
-	} else if ti.flagMissingFielderPtr {
-		toMap = true
-		if rv.CanAddr() {
-			mf = rv2i(rvAddr(rv, ti.ptr)).(MissingFielder).CodecMissingFields()
-		} else {
-			mf = rv2i(e.addrRV(rv, ti.rt, ti.ptr)).(MissingFielder).CodecMissingFields()
-		}
-	}
-	newlen := len(mf)
-	tisfi := ti.sfi.source()
-	newlen += len(tisfi)
-
-	var fkvs = e.slist.get(newlen)[:newlen]
-
-	recur := e.h.RecursiveEmptyCheck
-	chkCirRef := e.h.CheckCircularRef
-
-	var xlen int
-
-	var kv sfiRv
-	var j int
-	var sf encStructFieldObj
-	if toMap {
-		newlen = 0
-		if e.h.Canonical {
-			tisfi = f.ti.sfi.sorted()
-		}
-		for _, si := range tisfi {
-
-			if si.omitEmpty {
-				kv.r = si.fieldNoAlloc(rv, false)
-				if isEmptyValue(kv.r, e.h.TypeInfos, recur) {
-					continue
-				}
-			} else {
-				kv.r = si.fieldNoAlloc(rv, si.encBuiltin || !chkCirRef)
-			}
-			kv.v = si
-			fkvs[newlen] = kv
-			newlen++
-		}
-
-		var mf2s []stringIntf
-		if len(mf) != 0 {
-			mf2s = make([]stringIntf, 0, len(mf))
-			for k, v := range mf {
-				if k == "" {
-					continue
-				}
-				if ti.infoFieldOmitempty && isEmptyValue(reflect.ValueOf(v), e.h.TypeInfos, recur) {
-					continue
-				}
-				mf2s = append(mf2s, stringIntf{k, v})
-			}
-		}
-
-		xlen = newlen + len(mf2s)
-		if xlen == 0 {
-			e.e.WriteMapEmpty()
-			goto END
-		}
-
-		e.mapStart(xlen)
-
-		if len(mf2s) != 0 && e.h.Canonical {
-			mf2w := make([]encStructFieldObj, newlen+len(mf2s))
-			for j = 0; j < newlen; j++ {
-				kv = fkvs[j]
-				mf2w[j] = encStructFieldObj{kv.v.encName, kv.r, nil, true,
-					!kv.v.encNameEscape4Json, kv.v.encBuiltin}
-			}
-			for _, v := range mf2s {
-				mf2w[j] = encStructFieldObj{v.v, reflect.Value{}, v.i, false, false, false}
-				j++
-			}
-			sort.Sort((encStructFieldObjSlice)(mf2w))
-			for j, sf = range mf2w {
-				e.c = containerMapKey
-				e.e.WriteMapElemKey(j == 0)
-				if ti.keyType == valueTypeString && sf.noEsc4json {
-					e.e.EncodeStringNoEscape4Json(sf.key)
-				} else {
-					e.kStructFieldKey(ti.keyType, sf.key)
-				}
-				e.mapElemValue()
-				if sf.isRv {
-					if sf.builtin {
-						e.encodeIB(rv2i(baseRVRV(sf.rv)))
-					} else {
-						e.encodeValue(sf.rv, nil)
-					}
-				} else {
-					if !e.encodeBuiltin(sf.intf) {
-						e.encodeR(reflect.ValueOf(sf.intf))
-					}
-
-				}
-			}
-		} else {
-			keytyp := ti.keyType
-			for j = 0; j < newlen; j++ {
-				kv = fkvs[j]
-				e.c = containerMapKey
-				e.e.WriteMapElemKey(j == 0)
-				if ti.keyType == valueTypeString && !kv.v.encNameEscape4Json {
-					e.e.EncodeStringNoEscape4Json(kv.v.encName)
-				} else {
-					e.kStructFieldKey(keytyp, kv.v.encName)
-				}
-				e.mapElemValue()
-				if kv.v.encBuiltin {
-					e.encodeIB(rv2i(baseRVRV(kv.r)))
-				} else {
-					e.encodeValue(kv.r, nil)
-				}
-			}
-			for _, v := range mf2s {
-				e.c = containerMapKey
-				e.e.WriteMapElemKey(j == 0)
-				e.kStructFieldKey(keytyp, v.v)
-				e.mapElemValue()
-				if !e.encodeBuiltin(v.i) {
-					e.encodeR(reflect.ValueOf(v.i))
-				}
-
-				j++
-			}
-		}
-
-		e.c = 0
-		e.e.WriteMapEnd()
-	} else {
-		newlen = len(tisfi)
-		for i, si := range tisfi {
-
-			if si.omitEmpty {
-
-				kv.r = si.fieldNoAlloc(rv, false)
-				if isEmptyContainerValue(kv.r, e.h.TypeInfos, recur) {
-					kv.r = reflect.Value{}
-				}
-			} else {
-				kv.r = si.fieldNoAlloc(rv, si.encBuiltin || !chkCirRef)
-			}
-			kv.v = si
-			fkvs[i] = kv
-		}
-
-		if newlen == 0 {
-			e.e.WriteArrayEmpty()
-			goto END
-		}
-
-		e.arrayStart(newlen)
-		for j = 0; j < newlen; j++ {
-			e.c = containerArrayElem
-			e.e.WriteArrayElem(j == 0)
-			kv = fkvs[j]
-			if !kv.r.IsValid() {
-				e.e.EncodeNil()
-			} else if kv.v.encBuiltin {
-				e.encodeIB(rv2i(baseRVRV(kv.r)))
-			} else {
-				e.encodeValue(kv.r, nil)
-			}
-		}
-		e.c = 0
-		e.e.WriteArrayEnd()
-	}
-
-END:
-
-	e.slist.put(fkvs)
-}
-
-func (e *encoderMsgpackBytes) kMap(f *encFnInfo, rv reflect.Value) {
-	_ = e.e
-	l := rvLenMap(rv)
-	if l == 0 {
-		e.e.WriteMapEmpty()
-		return
-	}
-	e.mapStart(l)
-
-	var keyFn, valFn *encFnMsgpackBytes
-
-	ktypeKind := reflect.Kind(f.ti.keykind)
-	vtypeKind := reflect.Kind(f.ti.elemkind)
-
-	rtval := f.ti.elem
-	rtvalkind := vtypeKind
-	for rtvalkind == reflect.Ptr {
-		rtval = rtval.Elem()
-		rtvalkind = rtval.Kind()
-	}
-	if rtvalkind != reflect.Interface {
-		valFn = e.fn(rtval)
-	}
-
-	var rvv = mapAddrLoopvarRV(f.ti.elem, vtypeKind)
-
-	rtkey := f.ti.key
-	var keyTypeIsString = stringTypId == rt2id(rtkey)
-	if keyTypeIsString {
-		keyFn = e.fn(rtkey)
-	} else {
-		for rtkey.Kind() == reflect.Ptr {
-			rtkey = rtkey.Elem()
-		}
-		if rtkey.Kind() != reflect.Interface {
-			keyFn = e.fn(rtkey)
-		}
-	}
-
-	if e.h.Canonical {
-		e.kMapCanonical(f.ti, rv, rvv, keyFn, valFn)
-		e.c = 0
-		e.e.WriteMapEnd()
-		return
-	}
-
-	var rvk = mapAddrLoopvarRV(f.ti.key, ktypeKind)
-
-	var it mapIter
-	mapRange(&it, rv, rvk, rvv, true)
-
-	kbuiltin := f.ti.tikey.flagEncBuiltin
-	vbuiltin := f.ti.tielem.flagEncBuiltin
-	for j := 0; it.Next(); j++ {
-		rv = it.Key()
-		e.c = containerMapKey
-		e.e.WriteMapElemKey(j == 0)
-		if keyTypeIsString {
-			e.e.EncodeString(rvGetString(rv))
-		} else if kbuiltin {
-			e.encodeIB(rv2i(baseRVRV(rv)))
-		} else {
-			e.encodeValue(rv, keyFn)
-		}
-		e.mapElemValue()
-		rv = it.Value()
-		if vbuiltin {
-			e.encodeIB(rv2i(baseRVRV(rv)))
-		} else {
-			e.encodeValue(it.Value(), valFn)
-		}
-	}
-	it.Done()
-
-	e.c = 0
-	e.e.WriteMapEnd()
-}
-
-func (e *encoderMsgpackBytes) kMapCanonical(ti *typeInfo, rv, rvv reflect.Value, keyFn, valFn *encFnMsgpackBytes) {
-	_ = e.e
-
-	rtkey := ti.key
-	rtkeydecl := rtkey.PkgPath() == "" && rtkey.Name() != ""
-
-	mks := rv.MapKeys()
-	rtkeyKind := rtkey.Kind()
-	mparams := getMapReqParams(ti)
-
-	switch rtkeyKind {
-	case reflect.Bool:
-
-		if len(mks) == 2 && mks[0].Bool() {
-			mks[0], mks[1] = mks[1], mks[0]
-		}
-		for i := range mks {
-			e.c = containerMapKey
-			e.e.WriteMapElemKey(i == 0)
-			if rtkeydecl {
-				e.e.EncodeBool(mks[i].Bool())
-			} else {
-				e.encodeValueNonNil(mks[i], keyFn)
-			}
-			e.mapElemValue()
-			e.encodeValue(mapGet(rv, mks[i], rvv, mparams), valFn)
-		}
-	case reflect.String:
-		mksv := make([]orderedRv[string], len(mks))
-		for i, k := range mks {
-			v := &mksv[i]
-			v.r = k
-			v.v = rvGetString(k)
-		}
-		slices.SortFunc(mksv, cmpOrderedRv)
-		for i := range mksv {
-			e.c = containerMapKey
-			e.e.WriteMapElemKey(i == 0)
-			if rtkeydecl {
-				e.e.EncodeString(mksv[i].v)
-			} else {
-				e.encodeValueNonNil(mksv[i].r, keyFn)
-			}
-			e.mapElemValue()
-			e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn)
-		}
-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint, reflect.Uintptr:
-		mksv := make([]orderedRv[uint64], len(mks))
-		for i, k := range mks {
-			v := &mksv[i]
-			v.r = k
-			v.v = k.Uint()
-		}
-		slices.SortFunc(mksv, cmpOrderedRv)
-		for i := range mksv {
-			e.c = containerMapKey
-			e.e.WriteMapElemKey(i == 0)
-			if rtkeydecl {
-				e.e.EncodeUint(mksv[i].v)
-			} else {
-				e.encodeValueNonNil(mksv[i].r, keyFn)
-			}
-			e.mapElemValue()
-			e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn)
-		}
-	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-		mksv := make([]orderedRv[int64], len(mks))
-		for i, k := range mks {
-			v := &mksv[i]
-			v.r = k
-			v.v = k.Int()
-		}
-		slices.SortFunc(mksv, cmpOrderedRv)
-		for i := range mksv {
-			e.c = containerMapKey
-			e.e.WriteMapElemKey(i == 0)
-			if rtkeydecl {
-				e.e.EncodeInt(mksv[i].v)
-			} else {
-				e.encodeValueNonNil(mksv[i].r, keyFn)
-			}
-			e.mapElemValue()
-			e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn)
-		}
-	case reflect.Float32:
-		mksv := make([]orderedRv[float64], len(mks))
-		for i, k := range mks {
-			v := &mksv[i]
-			v.r = k
-			v.v = k.Float()
-		}
-		slices.SortFunc(mksv, cmpOrderedRv)
-		for i := range mksv {
-			e.c = containerMapKey
-			e.e.WriteMapElemKey(i == 0)
-			if rtkeydecl {
-				e.e.EncodeFloat32(float32(mksv[i].v))
-			} else {
-				e.encodeValueNonNil(mksv[i].r, keyFn)
-			}
-			e.mapElemValue()
-			e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn)
-		}
-	case reflect.Float64:
-		mksv := make([]orderedRv[float64], len(mks))
-		for i, k := range mks {
-			v := &mksv[i]
-			v.r = k
-			v.v = k.Float()
-		}
-		slices.SortFunc(mksv, cmpOrderedRv)
-		for i := range mksv {
-			e.c = containerMapKey
-			e.e.WriteMapElemKey(i == 0)
-			if rtkeydecl {
-				e.e.EncodeFloat64(mksv[i].v)
-			} else {
-				e.encodeValueNonNil(mksv[i].r, keyFn)
-			}
-			e.mapElemValue()
-			e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn)
-		}
-	default:
-		if rtkey == timeTyp {
-			mksv := make([]timeRv, len(mks))
-			for i, k := range mks {
-				v := &mksv[i]
-				v.r = k
-				v.v = rv2i(k).(time.Time)
-			}
-			slices.SortFunc(mksv, cmpTimeRv)
-			for i := range mksv {
-				e.c = containerMapKey
-				e.e.WriteMapElemKey(i == 0)
-				e.e.EncodeTime(mksv[i].v)
-				e.mapElemValue()
-				e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn)
-			}
-			break
-		}
-
-		bs0 := e.blist.get(len(mks) * 16)
-		mksv := bs0
-		mksbv := make([]bytesRv, len(mks))
-
-		sideEncode(e.hh, &e.h.sideEncPool, func(se encoderI) {
-			se.ResetBytes(&mksv)
-			for i, k := range mks {
-				v := &mksbv[i]
-				l := len(mksv)
-				se.setContainerState(containerMapKey)
-				se.encodeR(baseRVRV(k))
-				se.atEndOfEncode()
-				se.writerEnd()
-				v.r = k
-				v.v = mksv[l:]
-			}
-		})
-
-		slices.SortFunc(mksbv, cmpBytesRv)
-		for j := range mksbv {
-			e.c = containerMapKey
-			e.e.WriteMapElemKey(j == 0)
-			e.e.writeBytesAsis(mksbv[j].v)
-			e.mapElemValue()
-			e.encodeValue(mapGet(rv, mksbv[j].r, rvv, mparams), valFn)
-		}
-		e.blist.put(mksv)
-		if !byteSliceSameData(bs0, mksv) {
-			e.blist.put(bs0)
-		}
-	}
-}
-
-func (e *encoderMsgpackBytes) init(h Handle) {
-	initHandle(h)
-	callMake(&e.e)
-	e.hh = h
-	e.h = h.getBasicHandle()
-
-	e.err = errEncoderNotInitialized
-
-	e.fp = e.e.init(h, &e.encoderBase, e).(*fastpathEsMsgpackBytes)
-
-	if e.bytes {
-		e.rtidFn = &e.h.rtidFnsEncBytes
-		e.rtidFnNoExt = &e.h.rtidFnsEncNoExtBytes
-	} else {
-		e.rtidFn = &e.h.rtidFnsEncIO
-		e.rtidFnNoExt = &e.h.rtidFnsEncNoExtIO
-	}
-
-	e.reset()
-}
-
-func (e *encoderMsgpackBytes) reset() {
-	e.e.reset()
-	if e.ci != nil {
-		e.ci = e.ci[:0]
-	}
-	e.c = 0
-	e.calls = 0
-	e.seq = 0
-	e.err = nil
-}
-
-func (e *encoderMsgpackBytes) Encode(v interface{}) (err error) {
-
-	defer panicValToErr(e, callRecoverSentinel, &e.err, &err, debugging)
-	e.mustEncode(v)
-	return
-}
-
-func (e *encoderMsgpackBytes) MustEncode(v interface{}) {
-	defer panicValToErr(e, callRecoverSentinel, &e.err, nil, true)
-	e.mustEncode(v)
-	return
-}
-
-func (e *encoderMsgpackBytes) mustEncode(v interface{}) {
-	halt.onerror(e.err)
-	if e.hh == nil {
-		halt.onerror(errNoFormatHandle)
-	}
-
-	e.calls++
-	if !e.encodeBuiltin(v) {
-		e.encodeR(reflect.ValueOf(v))
-	}
-
-	e.calls--
-	if e.calls == 0 {
-		e.e.atEndOfEncode()
-		e.e.writerEnd()
-	}
-}
-
-func (e *encoderMsgpackBytes) encodeI(iv interface{}) {
-	if !e.encodeBuiltin(iv) {
-		e.encodeR(reflect.ValueOf(iv))
-	}
-}
-
-func (e *encoderMsgpackBytes) encodeIB(iv interface{}) {
-	if !e.encodeBuiltin(iv) {
-
-		halt.errorStr("[should not happen] invalid type passed to encodeBuiltin")
-	}
-}
-
-func (e *encoderMsgpackBytes) encodeR(base reflect.Value) {
-	e.encodeValue(base, nil)
-}
-
-func (e *encoderMsgpackBytes) encodeBuiltin(iv interface{}) (ok bool) {
-	ok = true
-	switch v := iv.(type) {
-	case nil:
-		e.e.EncodeNil()
-
-	case Raw:
-		e.rawBytes(v)
-	case string:
-		e.e.EncodeString(v)
-	case bool:
-		e.e.EncodeBool(v)
-	case int:
-		e.e.EncodeInt(int64(v))
-	case int8:
-		e.e.EncodeInt(int64(v))
-	case int16:
-		e.e.EncodeInt(int64(v))
-	case int32:
-		e.e.EncodeInt(int64(v))
-	case int64:
-		e.e.EncodeInt(v)
-	case uint:
-		e.e.EncodeUint(uint64(v))
-	case uint8:
-		e.e.EncodeUint(uint64(v))
-	case uint16:
-		e.e.EncodeUint(uint64(v))
-	case uint32:
-		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 complex64:
-		e.encodeComplex64(v)
-	case complex128:
-		e.encodeComplex128(v)
-	case time.Time:
-		e.e.EncodeTime(v)
-	case []byte:
-		e.e.EncodeBytes(v)
-	default:
-
-		ok = !skipFastpathTypeSwitchInDirectCall && e.dh.fastpathEncodeTypeSwitch(iv, e)
-	}
-	return
-}
-
-func (e *encoderMsgpackBytes) encodeValue(rv reflect.Value, fn *encFnMsgpackBytes) {
-
-	var ciPushes int
-
-	var rvp reflect.Value
-	var rvpValid bool
-
-RV:
-	switch rv.Kind() {
-	case reflect.Ptr:
-		if rvIsNil(rv) {
-			e.e.EncodeNil()
-			goto END
-		}
-		rvpValid = true
-		rvp = rv
-		rv = rv.Elem()
-
-		if e.h.CheckCircularRef && e.ci.canPushElemKind(rv.Kind()) {
-			e.ci.push(rv2i(rvp))
-			ciPushes++
-		}
-		goto RV
-	case reflect.Interface:
-		if rvIsNil(rv) {
-			e.e.EncodeNil()
-			goto END
-		}
-		rvpValid = false
-		rvp = reflect.Value{}
-		rv = rv.Elem()
-		fn = nil
-		goto RV
-	case reflect.Map:
-		if rvIsNil(rv) {
-			if e.h.NilCollectionToZeroLength {
-				e.e.WriteMapEmpty()
-			} else {
-				e.e.EncodeNil()
-			}
-			goto END
-		}
-	case reflect.Slice, reflect.Chan:
-		if rvIsNil(rv) {
-			if e.h.NilCollectionToZeroLength {
-				e.e.WriteArrayEmpty()
-			} else {
-				e.e.EncodeNil()
-			}
-			goto END
-		}
-	case reflect.Invalid, reflect.Func:
-		e.e.EncodeNil()
-		goto END
-	}
-
-	if fn == nil {
-		fn = e.fn(rv.Type())
-	}
-
-	if !fn.i.addrE {
-
-	} else if rvpValid {
-		rv = rvp
-	} else if rv.CanAddr() {
-		rv = rvAddr(rv, fn.i.ti.ptr)
-	} else {
-		rv = e.addrRV(rv, fn.i.ti.rt, fn.i.ti.ptr)
-	}
-	fn.fe(e, &fn.i, rv)
-
-END:
-	if ciPushes > 0 {
-		e.ci.pop(ciPushes)
-	}
-}
-
-func (e *encoderMsgpackBytes) encodeValueNonNil(rv reflect.Value, fn *encFnMsgpackBytes) {
-
-	if fn.i.addrE {
-		if rv.CanAddr() {
-			rv = rvAddr(rv, fn.i.ti.ptr)
-		} else {
-			rv = e.addrRV(rv, fn.i.ti.rt, fn.i.ti.ptr)
-		}
-	}
-	fn.fe(e, &fn.i, rv)
-}
-
-func (e *encoderMsgpackBytes) encodeAs(v interface{}, t reflect.Type, ext bool) {
-	if ext {
-		e.encodeValue(baseRV(v), e.fn(t))
-	} else {
-		e.encodeValue(baseRV(v), e.fnNoExt(t))
-	}
-}
-
-func (e *encoderMsgpackBytes) marshalUtf8(bs []byte, fnerr error) {
-	halt.onerror(fnerr)
-	if bs == nil {
-		e.e.EncodeNil()
-	} else {
-		e.e.EncodeString(stringView(bs))
-	}
-}
-
-func (e *encoderMsgpackBytes) marshalAsis(bs []byte, fnerr error) {
-	halt.onerror(fnerr)
-	if bs == nil {
-		e.e.EncodeNil()
-	} else {
-		e.e.writeBytesAsis(bs)
-	}
-}
-
-func (e *encoderMsgpackBytes) marshalRaw(bs []byte, fnerr error) {
-	halt.onerror(fnerr)
-	e.e.EncodeBytes(bs)
-}
-
-func (e *encoderMsgpackBytes) rawBytes(vv Raw) {
-	v := []byte(vv)
-	if !e.h.Raw {
-		halt.errorBytes("Raw values cannot be encoded: ", v)
-	}
-	e.e.writeBytesAsis(v)
-}
-
-func (e *encoderMsgpackBytes) fn(t reflect.Type) *encFnMsgpackBytes {
-	return e.dh.encFnViaBH(t, e.rtidFn, e.h, e.fp, false)
-}
-
-func (e *encoderMsgpackBytes) fnNoExt(t reflect.Type) *encFnMsgpackBytes {
-	return e.dh.encFnViaBH(t, e.rtidFnNoExt, e.h, e.fp, true)
-}
-
-func (e *encoderMsgpackBytes) mapStart(length int) {
-	e.e.WriteMapStart(length)
-	e.c = containerMapStart
-}
-
-func (e *encoderMsgpackBytes) mapElemValue() {
-	e.e.WriteMapElemValue()
-	e.c = containerMapValue
-}
-
-func (e *encoderMsgpackBytes) arrayStart(length int) {
-	e.e.WriteArrayStart(length)
-	e.c = containerArrayStart
-}
-
-func (e *encoderMsgpackBytes) writerEnd() {
-	e.e.writerEnd()
-}
-
-func (e *encoderMsgpackBytes) atEndOfEncode() {
-	e.e.atEndOfEncode()
-}
-
-func (e *encoderMsgpackBytes) Reset(w io.Writer) {
-	if e.bytes {
-		halt.onerror(errEncNoResetBytesWithWriter)
-	}
-	e.reset()
-	if w == nil {
-		w = io.Discard
-	}
-	e.e.resetOutIO(w)
-}
-
-func (e *encoderMsgpackBytes) ResetBytes(out *[]byte) {
-	if !e.bytes {
-		halt.onerror(errEncNoResetWriterWithBytes)
-	}
-	e.resetBytes(out)
-}
-
-func (e *encoderMsgpackBytes) resetBytes(out *[]byte) {
-	e.reset()
-	if out == nil {
-		out = &bytesEncAppenderDefOut
-	}
-	e.e.resetOutBytes(out)
-}
-
-func (helperEncDriverMsgpackBytes) newEncoderBytes(out *[]byte, h Handle) *encoderMsgpackBytes {
-	var c1 encoderMsgpackBytes
-	c1.bytes = true
-	c1.init(h)
-	c1.ResetBytes(out)
-	return &c1
-}
-
-func (helperEncDriverMsgpackBytes) newEncoderIO(out io.Writer, h Handle) *encoderMsgpackBytes {
-	var c1 encoderMsgpackBytes
-	c1.bytes = false
-	c1.init(h)
-	c1.Reset(out)
-	return &c1
-}
-
-func (helperEncDriverMsgpackBytes) encFnloadFastpathUnderlying(ti *typeInfo, fp *fastpathEsMsgpackBytes) (f *fastpathEMsgpackBytes, u reflect.Type) {
-	rtid := rt2id(ti.fastpathUnderlying)
-	idx, ok := fastpathAvIndex(rtid)
-	if !ok {
-		return
-	}
-	f = &fp[idx]
-	if uint8(reflect.Array) == ti.kind {
-		u = reflect.ArrayOf(ti.rt.Len(), ti.elem)
-	} else {
-		u = f.rt
-	}
-	return
-}
-
-func (helperEncDriverMsgpackBytes) encFindRtidFn(s []encRtidFnMsgpackBytes, rtid uintptr) (i uint, fn *encFnMsgpackBytes) {
-
-	var h uint
-	var j = uint(len(s))
-LOOP:
-	if i < j {
-		h = (i + j) >> 1
-		if s[h].rtid < rtid {
-			i = h + 1
-		} else {
-			j = h
-		}
-		goto LOOP
-	}
-	if i < uint(len(s)) && s[i].rtid == rtid {
-		fn = s[i].fn
-	}
-	return
-}
-
-func (helperEncDriverMsgpackBytes) encFromRtidFnSlice(fns *atomicRtidFnSlice) (s []encRtidFnMsgpackBytes) {
-	if v := fns.load(); v != nil {
-		s = *(lowLevelToPtr[[]encRtidFnMsgpackBytes](v))
-	}
-	return
-}
-
-func (dh helperEncDriverMsgpackBytes) encFnViaBH(rt reflect.Type, fns *atomicRtidFnSlice,
-	x *BasicHandle, fp *fastpathEsMsgpackBytes, checkExt bool) (fn *encFnMsgpackBytes) {
-	return dh.encFnVia(rt, fns, x.typeInfos(), &x.mu, x.extHandle, fp,
-		checkExt, x.CheckCircularRef, x.timeBuiltin, x.binaryHandle, x.jsonHandle)
-}
-
-func (dh helperEncDriverMsgpackBytes) encFnVia(rt reflect.Type, fns *atomicRtidFnSlice,
-	tinfos *TypeInfos, mu *sync.Mutex, exth extHandle, fp *fastpathEsMsgpackBytes,
-	checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *encFnMsgpackBytes) {
-	rtid := rt2id(rt)
-	var sp []encRtidFnMsgpackBytes = dh.encFromRtidFnSlice(fns)
-	if sp != nil {
-		_, fn = dh.encFindRtidFn(sp, rtid)
-	}
-	if fn == nil {
-		fn = dh.encFnViaLoader(rt, rtid, fns, tinfos, mu, exth, fp, checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json)
-	}
-	return
-}
-
-func (dh helperEncDriverMsgpackBytes) encFnViaLoader(rt reflect.Type, rtid uintptr, fns *atomicRtidFnSlice,
-	tinfos *TypeInfos, mu *sync.Mutex, exth extHandle, fp *fastpathEsMsgpackBytes,
-	checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *encFnMsgpackBytes) {
-
-	fn = dh.encFnLoad(rt, rtid, tinfos, exth, fp, checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json)
-	var sp []encRtidFnMsgpackBytes
-	mu.Lock()
-	sp = dh.encFromRtidFnSlice(fns)
-
-	if sp == nil {
-		sp = []encRtidFnMsgpackBytes{{rtid, fn}}
-		fns.store(ptrToLowLevel(&sp))
-	} else {
-		idx, fn2 := dh.encFindRtidFn(sp, rtid)
-		if fn2 == nil {
-			sp2 := make([]encRtidFnMsgpackBytes, len(sp)+1)
-			copy(sp2[idx+1:], sp[idx:])
-			copy(sp2, sp[:idx])
-			sp2[idx] = encRtidFnMsgpackBytes{rtid, fn}
-			fns.store(ptrToLowLevel(&sp2))
-		}
-	}
-	mu.Unlock()
-	return
-}
-
-func (dh helperEncDriverMsgpackBytes) encFnLoad(rt reflect.Type, rtid uintptr, tinfos *TypeInfos,
-	exth extHandle, fp *fastpathEsMsgpackBytes,
-	checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *encFnMsgpackBytes) {
-	fn = new(encFnMsgpackBytes)
-	fi := &(fn.i)
-	ti := tinfos.get(rtid, rt)
-	fi.ti = ti
-	rk := reflect.Kind(ti.kind)
-
-	if rtid == timeTypId && timeBuiltin {
-		fn.fe = (*encoderMsgpackBytes).kTime
-	} else if rtid == rawTypId {
-		fn.fe = (*encoderMsgpackBytes).raw
-	} else if rtid == rawExtTypId {
-		fn.fe = (*encoderMsgpackBytes).rawExt
-		fi.addrE = true
-	} else if xfFn := exth.getExt(rtid, checkExt); xfFn != nil {
-		fi.xfTag, fi.xfFn = xfFn.tag, xfFn.ext
-		fn.fe = (*encoderMsgpackBytes).ext
-		if rk == reflect.Struct || rk == reflect.Array {
-			fi.addrE = true
-		}
-	} else if ti.flagSelfer || ti.flagSelferPtr {
-		fn.fe = (*encoderMsgpackBytes).selferMarshal
-		fi.addrE = ti.flagSelferPtr
-	} else if supportMarshalInterfaces && binaryEncoding &&
-		(ti.flagBinaryMarshaler || ti.flagBinaryMarshalerPtr) &&
-		(ti.flagBinaryUnmarshaler || ti.flagBinaryUnmarshalerPtr) {
-		fn.fe = (*encoderMsgpackBytes).binaryMarshal
-		fi.addrE = ti.flagBinaryMarshalerPtr
-	} else if supportMarshalInterfaces && !binaryEncoding && json &&
-		(ti.flagJsonMarshaler || ti.flagJsonMarshalerPtr) &&
-		(ti.flagJsonUnmarshaler || ti.flagJsonUnmarshalerPtr) {
-
-		fn.fe = (*encoderMsgpackBytes).jsonMarshal
-		fi.addrE = ti.flagJsonMarshalerPtr
-	} else if supportMarshalInterfaces && !binaryEncoding &&
-		(ti.flagTextMarshaler || ti.flagTextMarshalerPtr) &&
-		(ti.flagTextUnmarshaler || ti.flagTextUnmarshalerPtr) {
-		fn.fe = (*encoderMsgpackBytes).textMarshal
-		fi.addrE = ti.flagTextMarshalerPtr
-	} else {
-		if fastpathEnabled && (rk == reflect.Map || rk == reflect.Slice || rk == reflect.Array) {
-
-			var rtid2 uintptr
-			if !ti.flagHasPkgPath {
-				rtid2 = rtid
-				if rk == reflect.Array {
-					rtid2 = rt2id(ti.key)
-				}
-				if idx, ok := fastpathAvIndex(rtid2); ok {
-					fn.fe = fp[idx].encfn
-				}
-			} else {
-
-				xfe, xrt := dh.encFnloadFastpathUnderlying(ti, fp)
-				if xfe != nil {
-					xfnf := xfe.encfn
-					fn.fe = func(e *encoderMsgpackBytes, xf *encFnInfo, xrv reflect.Value) {
-						xfnf(e, xf, rvConvert(xrv, xrt))
-					}
-				}
-			}
-		}
-		if fn.fe == nil {
-			switch rk {
-			case reflect.Bool:
-				fn.fe = (*encoderMsgpackBytes).kBool
-			case reflect.String:
-
-				fn.fe = (*encoderMsgpackBytes).kString
-			case reflect.Int:
-				fn.fe = (*encoderMsgpackBytes).kInt
-			case reflect.Int8:
-				fn.fe = (*encoderMsgpackBytes).kInt8
-			case reflect.Int16:
-				fn.fe = (*encoderMsgpackBytes).kInt16
-			case reflect.Int32:
-				fn.fe = (*encoderMsgpackBytes).kInt32
-			case reflect.Int64:
-				fn.fe = (*encoderMsgpackBytes).kInt64
-			case reflect.Uint:
-				fn.fe = (*encoderMsgpackBytes).kUint
-			case reflect.Uint8:
-				fn.fe = (*encoderMsgpackBytes).kUint8
-			case reflect.Uint16:
-				fn.fe = (*encoderMsgpackBytes).kUint16
-			case reflect.Uint32:
-				fn.fe = (*encoderMsgpackBytes).kUint32
-			case reflect.Uint64:
-				fn.fe = (*encoderMsgpackBytes).kUint64
-			case reflect.Uintptr:
-				fn.fe = (*encoderMsgpackBytes).kUintptr
-			case reflect.Float32:
-				fn.fe = (*encoderMsgpackBytes).kFloat32
-			case reflect.Float64:
-				fn.fe = (*encoderMsgpackBytes).kFloat64
-			case reflect.Complex64:
-				fn.fe = (*encoderMsgpackBytes).kComplex64
-			case reflect.Complex128:
-				fn.fe = (*encoderMsgpackBytes).kComplex128
-			case reflect.Chan:
-				fn.fe = (*encoderMsgpackBytes).kChan
-			case reflect.Slice:
-				fn.fe = (*encoderMsgpackBytes).kSlice
-			case reflect.Array:
-				fn.fe = (*encoderMsgpackBytes).kArray
-			case reflect.Struct:
-				if ti.simple {
-					fn.fe = (*encoderMsgpackBytes).kStructSimple
-				} else {
-					fn.fe = (*encoderMsgpackBytes).kStruct
-				}
-			case reflect.Map:
-				fn.fe = (*encoderMsgpackBytes).kMap
-			case reflect.Interface:
-
-				fn.fe = (*encoderMsgpackBytes).kErr
-			default:
-
-				fn.fe = (*encoderMsgpackBytes).kErr
-			}
-		}
-	}
-	return
-}
-func (d *decoderMsgpackBytes) rawExt(f *decFnInfo, rv reflect.Value) {
-	d.d.DecodeRawExt(rv2i(rv).(*RawExt))
-}
-
-func (d *decoderMsgpackBytes) ext(f *decFnInfo, rv reflect.Value) {
-	d.d.DecodeExt(rv2i(rv), f.ti.rt, f.xfTag, f.xfFn)
-}
-
-func (d *decoderMsgpackBytes) selferUnmarshal(_ *decFnInfo, rv reflect.Value) {
-	rv2i(rv).(Selfer).CodecDecodeSelf(&Decoder{d})
-}
-
-func (d *decoderMsgpackBytes) binaryUnmarshal(_ *decFnInfo, rv reflect.Value) {
-	bm := rv2i(rv).(encoding.BinaryUnmarshaler)
-	xbs, _ := d.d.DecodeBytes()
-	fnerr := bm.UnmarshalBinary(xbs)
-	halt.onerror(fnerr)
-}
-
-func (d *decoderMsgpackBytes) textUnmarshal(_ *decFnInfo, rv reflect.Value) {
-	tm := rv2i(rv).(encoding.TextUnmarshaler)
-	fnerr := tm.UnmarshalText(bytesOKs(d.d.DecodeStringAsBytes()))
-	halt.onerror(fnerr)
-}
-
-func (d *decoderMsgpackBytes) jsonUnmarshal(_ *decFnInfo, rv reflect.Value) {
-	d.jsonUnmarshalV(rv2i(rv).(jsonUnmarshaler))
-}
-
-func (d *decoderMsgpackBytes) jsonUnmarshalV(tm jsonUnmarshaler) {
-
-	halt.onerror(tm.UnmarshalJSON(d.d.nextValueBytes()))
-}
-
-func (d *decoderMsgpackBytes) kErr(_ *decFnInfo, rv reflect.Value) {
-	halt.errorf("unsupported decoding kind: %s, for %#v", rv.Kind(), rv)
-
-}
-
-func (d *decoderMsgpackBytes) raw(_ *decFnInfo, rv reflect.Value) {
-	rvSetBytes(rv, d.rawBytes())
-}
-
-func (d *decoderMsgpackBytes) kString(_ *decFnInfo, rv reflect.Value) {
-	rvSetString(rv, d.detach2Str(d.d.DecodeStringAsBytes()))
-}
-
-func (d *decoderMsgpackBytes) kBool(_ *decFnInfo, rv reflect.Value) {
-	rvSetBool(rv, d.d.DecodeBool())
-}
-
-func (d *decoderMsgpackBytes) kTime(_ *decFnInfo, rv reflect.Value) {
-	rvSetTime(rv, d.d.DecodeTime())
-}
-
-func (d *decoderMsgpackBytes) kFloat32(_ *decFnInfo, rv reflect.Value) {
-	rvSetFloat32(rv, d.d.DecodeFloat32())
-}
-
-func (d *decoderMsgpackBytes) kFloat64(_ *decFnInfo, rv reflect.Value) {
-	rvSetFloat64(rv, d.d.DecodeFloat64())
-}
-
-func (d *decoderMsgpackBytes) kComplex64(_ *decFnInfo, rv reflect.Value) {
-	rvSetComplex64(rv, complex(d.d.DecodeFloat32(), 0))
-}
-
-func (d *decoderMsgpackBytes) kComplex128(_ *decFnInfo, rv reflect.Value) {
-	rvSetComplex128(rv, complex(d.d.DecodeFloat64(), 0))
-}
-
-func (d *decoderMsgpackBytes) kInt(_ *decFnInfo, rv reflect.Value) {
-	rvSetInt(rv, int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize)))
-}
-
-func (d *decoderMsgpackBytes) kInt8(_ *decFnInfo, rv reflect.Value) {
-	rvSetInt8(rv, int8(chkOvf.IntV(d.d.DecodeInt64(), 8)))
-}
-
-func (d *decoderMsgpackBytes) kInt16(_ *decFnInfo, rv reflect.Value) {
-	rvSetInt16(rv, int16(chkOvf.IntV(d.d.DecodeInt64(), 16)))
-}
-
-func (d *decoderMsgpackBytes) kInt32(_ *decFnInfo, rv reflect.Value) {
-	rvSetInt32(rv, int32(chkOvf.IntV(d.d.DecodeInt64(), 32)))
-}
-
-func (d *decoderMsgpackBytes) kInt64(_ *decFnInfo, rv reflect.Value) {
-	rvSetInt64(rv, d.d.DecodeInt64())
-}
-
-func (d *decoderMsgpackBytes) kUint(_ *decFnInfo, rv reflect.Value) {
-	rvSetUint(rv, uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize)))
-}
-
-func (d *decoderMsgpackBytes) kUintptr(_ *decFnInfo, rv reflect.Value) {
-	rvSetUintptr(rv, uintptr(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize)))
-}
-
-func (d *decoderMsgpackBytes) kUint8(_ *decFnInfo, rv reflect.Value) {
-	rvSetUint8(rv, uint8(chkOvf.UintV(d.d.DecodeUint64(), 8)))
-}
-
-func (d *decoderMsgpackBytes) kUint16(_ *decFnInfo, rv reflect.Value) {
-	rvSetUint16(rv, uint16(chkOvf.UintV(d.d.DecodeUint64(), 16)))
-}
-
-func (d *decoderMsgpackBytes) kUint32(_ *decFnInfo, rv reflect.Value) {
-	rvSetUint32(rv, uint32(chkOvf.UintV(d.d.DecodeUint64(), 32)))
-}
-
-func (d *decoderMsgpackBytes) kUint64(_ *decFnInfo, rv reflect.Value) {
-	rvSetUint64(rv, d.d.DecodeUint64())
-}
-
-func (d *decoderMsgpackBytes) kInterfaceNaked(f *decFnInfo) (rvn reflect.Value) {
-
-	n := d.naked()
-	d.d.DecodeNaked()
-
-	if decFailNonEmptyIntf && f.ti.numMeth > 0 {
-		halt.errorf("cannot decode non-nil codec value into nil %v (%v methods)", f.ti.rt, f.ti.numMeth)
-	}
-
-	switch n.v {
-	case valueTypeMap:
-		mtid := d.mtid
-		if mtid == 0 {
-			if d.jsms {
-				mtid = mapStrIntfTypId
-			} else {
-				mtid = mapIntfIntfTypId
-			}
-		}
-		if mtid == mapStrIntfTypId {
-			var v2 map[string]interface{}
-			d.decode(&v2)
-			rvn = rv4iptr(&v2).Elem()
-		} else if mtid == mapIntfIntfTypId {
-			var v2 map[interface{}]interface{}
-			d.decode(&v2)
-			rvn = rv4iptr(&v2).Elem()
-		} else if d.mtr {
-			rvn = reflect.New(d.h.MapType)
-			d.decode(rv2i(rvn))
-			rvn = rvn.Elem()
-		} else {
-
-			rvn = rvZeroAddrK(d.h.MapType, reflect.Map)
-			d.decodeValue(rvn, nil)
-		}
-	case valueTypeArray:
-		if d.stid == 0 || d.stid == intfSliceTypId {
-			var v2 []interface{}
-			d.decode(&v2)
-			rvn = rv4iptr(&v2).Elem()
-		} else if d.str {
-			rvn = reflect.New(d.h.SliceType)
-			d.decode(rv2i(rvn))
-			rvn = rvn.Elem()
-		} else {
-			rvn = rvZeroAddrK(d.h.SliceType, reflect.Slice)
-			d.decodeValue(rvn, nil)
-		}
-		if d.h.PreferArrayOverSlice {
-			rvn = rvGetArray4Slice(rvn)
-		}
-	case valueTypeExt:
-		tag, bytes := n.u, n.l
-		bfn := d.h.getExtForTag(tag)
-		var re = RawExt{Tag: tag}
-		if bytes == nil {
-
-			if bfn == nil {
-				d.decode(&re.Value)
-				rvn = rv4iptr(&re).Elem()
-			} else if bfn.ext == SelfExt {
-				rvn = rvZeroAddrK(bfn.rt, bfn.rt.Kind())
-				d.decodeValue(rvn, d.fnNoExt(bfn.rt))
-			} else {
-				rvn = reflect.New(bfn.rt)
-				d.interfaceExtConvertAndDecode(rv2i(rvn), bfn.ext)
-				rvn = rvn.Elem()
-			}
-		} else {
-
-			if bfn == nil {
-				re.setData(bytes, false)
-				rvn = rv4iptr(&re).Elem()
-			} else {
-				rvn = reflect.New(bfn.rt)
-				if bfn.ext == SelfExt {
-					sideDecode(d.hh, &d.h.sideDecPool, func(sd decoderI) { oneOffDecode(sd, rv2i(rvn), bytes, bfn.rt, true) })
-				} else {
-					bfn.ext.ReadExt(rv2i(rvn), bytes)
-				}
-				rvn = rvn.Elem()
-			}
-		}
-
-		if d.h.PreferPointerForStructOrArray && rvn.CanAddr() {
-			if rk := rvn.Kind(); rk == reflect.Array || rk == reflect.Struct {
-				rvn = rvn.Addr()
-			}
-		}
-	case valueTypeNil:
-
-	case valueTypeInt:
-		rvn = n.ri()
-	case valueTypeUint:
-		rvn = n.ru()
-	case valueTypeFloat:
-		rvn = n.rf()
-	case valueTypeBool:
-		rvn = n.rb()
-	case valueTypeString, valueTypeSymbol:
-		rvn = n.rs()
-	case valueTypeBytes:
-		rvn = n.rl()
-	case valueTypeTime:
-		rvn = n.rt()
-	default:
-		halt.errorStr2("kInterfaceNaked: unexpected valueType: ", n.v.String())
-	}
-	return
-}
-
-func (d *decoderMsgpackBytes) kInterface(f *decFnInfo, rv reflect.Value) {
-
-	isnilrv := rvIsNil(rv)
-
-	var rvn reflect.Value
-
-	if d.h.InterfaceReset {
-
-		rvn = d.h.intf2impl(f.ti.rtid)
-		if !rvn.IsValid() {
-			rvn = d.kInterfaceNaked(f)
-			if rvn.IsValid() {
-				rvSetIntf(rv, rvn)
-			} else if !isnilrv {
-				decSetNonNilRV2Zero4Intf(rv)
-			}
-			return
-		}
-	} else if isnilrv {
-
-		rvn = d.h.intf2impl(f.ti.rtid)
-		if !rvn.IsValid() {
-			rvn = d.kInterfaceNaked(f)
-			if rvn.IsValid() {
-				rvSetIntf(rv, rvn)
-			}
-			return
-		}
-	} else {
-
-		rvn = rv.Elem()
-	}
-
-	canDecode, _ := isDecodeable(rvn)
-
-	if !canDecode {
-		rvn2 := d.oneShotAddrRV(rvn.Type(), rvn.Kind())
-		rvSetDirect(rvn2, rvn)
-		rvn = rvn2
-	}
-
-	d.decodeValue(rvn, nil)
-	rvSetIntf(rv, rvn)
-}
-
-func (d *decoderMsgpackBytes) kStructField(si *structFieldInfo, rv reflect.Value) {
-	if d.d.TryNil() {
-		rv = si.fieldNoAlloc(rv, true)
-		if rv.IsValid() {
-			decSetNonNilRV2Zero(rv)
-		}
-	} else if si.decBuiltin {
-		rv = rvAddr(si.fieldAlloc(rv), si.ptrTyp)
-		d.decode(rv2i(rv))
-	} else {
-		fn := d.fn(si.baseTyp)
-		rv = si.fieldAlloc(rv)
-		if fn.i.addrD {
-			rv = rvAddr(rv, si.ptrTyp)
-		}
-		fn.fd(d, &fn.i, rv)
-	}
-}
-
-func (d *decoderMsgpackBytes) kStructSimple(f *decFnInfo, rv reflect.Value) {
-	_ = d.d
-	ctyp := d.d.ContainerType()
-	ti := f.ti
-	if ctyp == valueTypeMap {
-		containerLen := d.mapStart(d.d.ReadMapStart())
-		if containerLen == 0 {
-			d.mapEnd()
-			return
-		}
-		hasLen := containerLen >= 0
-		var rvkencname []byte
-		for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
-			d.mapElemKey(j == 0)
-			sab, att := d.d.DecodeStringAsBytes()
-			rvkencname = d.usableStructFieldNameBytes(rvkencname, sab, att)
-			d.mapElemValue()
-			if si := ti.siForEncName(rvkencname); si != nil {
-				d.kStructField(si, rv)
-			} else {
-				d.structFieldNotFound(-1, stringView(rvkencname))
-			}
-		}
-		d.mapEnd()
-	} else if ctyp == valueTypeArray {
-		containerLen := d.arrayStart(d.d.ReadArrayStart())
-		if containerLen == 0 {
-			d.arrayEnd()
-			return
-		}
-
-		tisfi := ti.sfi.source()
-		hasLen := containerLen >= 0
-
-		for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
-			d.arrayElem(j == 0)
-			if j < len(tisfi) {
-				d.kStructField(tisfi[j], rv)
-			} else {
-				d.structFieldNotFound(j, "")
-			}
-		}
-		d.arrayEnd()
-	} else {
-		halt.onerror(errNeedMapOrArrayDecodeToStruct)
-	}
-}
-
-func (d *decoderMsgpackBytes) kStruct(f *decFnInfo, rv reflect.Value) {
-	_ = d.d
-	ctyp := d.d.ContainerType()
-	ti := f.ti
-	var mf MissingFielder
-	if ti.flagMissingFielder {
-		mf = rv2i(rv).(MissingFielder)
-	} else if ti.flagMissingFielderPtr {
-		mf = rv2i(rvAddr(rv, ti.ptr)).(MissingFielder)
-	}
-	if ctyp == valueTypeMap {
-		containerLen := d.mapStart(d.d.ReadMapStart())
-		if containerLen == 0 {
-			d.mapEnd()
-			return
-		}
-		hasLen := containerLen >= 0
-		var name2 []byte
-		var rvkencname []byte
-		tkt := ti.keyType
-		for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
-			d.mapElemKey(j == 0)
-
-			if tkt == valueTypeString {
-				sab, att := d.d.DecodeStringAsBytes()
-				rvkencname = d.usableStructFieldNameBytes(rvkencname, sab, att)
-			} else if tkt == valueTypeInt {
-				rvkencname = strconv.AppendInt(d.b[:0], d.d.DecodeInt64(), 10)
-			} else if tkt == valueTypeUint {
-				rvkencname = strconv.AppendUint(d.b[:0], d.d.DecodeUint64(), 10)
-			} else if tkt == valueTypeFloat {
-				rvkencname = strconv.AppendFloat(d.b[:0], d.d.DecodeFloat64(), 'f', -1, 64)
-			} else {
-				halt.errorStr2("invalid struct key type: ", ti.keyType.String())
-			}
-
-			d.mapElemValue()
-			if si := ti.siForEncName(rvkencname); si != nil {
-				d.kStructField(si, rv)
-			} else if mf != nil {
-
-				name2 = append(name2[:0], rvkencname...)
-				var f interface{}
-				d.decode(&f)
-				if !mf.CodecMissingField(name2, f) && d.h.ErrorIfNoField {
-					halt.errorStr2("no matching struct field when decoding stream map with key: ", stringView(name2))
-				}
-			} else {
-				d.structFieldNotFound(-1, stringView(rvkencname))
-			}
-		}
-		d.mapEnd()
-	} else if ctyp == valueTypeArray {
-		containerLen := d.arrayStart(d.d.ReadArrayStart())
-		if containerLen == 0 {
-			d.arrayEnd()
-			return
-		}
-
-		tisfi := ti.sfi.source()
-		hasLen := containerLen >= 0
-
-		for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
-			d.arrayElem(j == 0)
-			if j < len(tisfi) {
-				d.kStructField(tisfi[j], rv)
-			} else {
-				d.structFieldNotFound(j, "")
-			}
-		}
-
-		d.arrayEnd()
-	} else {
-		halt.onerror(errNeedMapOrArrayDecodeToStruct)
-	}
-}
-
-func (d *decoderMsgpackBytes) kSlice(f *decFnInfo, rv reflect.Value) {
-	_ = d.d
-
-	ti := f.ti
-	rvCanset := rv.CanSet()
-
-	ctyp := d.d.ContainerType()
-	if ctyp == valueTypeBytes || ctyp == valueTypeString {
-
-		if !(ti.rtid == uint8SliceTypId || ti.elemkind == uint8(reflect.Uint8)) {
-			halt.errorf("bytes/string in stream must decode into slice/array of bytes, not %v", ti.rt)
-		}
-		rvbs := rvGetBytes(rv)
-		if rvCanset {
-			bs2, bst := d.decodeBytesInto(rvbs, false)
-			if bst != dBytesIntoParamOut {
-				rvSetBytes(rv, bs2)
-			}
-		} else {
-
-			d.decodeBytesInto(rvbs[:len(rvbs):len(rvbs)], true)
-		}
-		return
-	}
-
-	var containerLenS int
-	isArray := ctyp == valueTypeArray
-	if isArray {
-		containerLenS = d.arrayStart(d.d.ReadArrayStart())
-	} else if ctyp == valueTypeMap {
-		containerLenS = d.mapStart(d.d.ReadMapStart()) * 2
-	} else {
-		halt.errorStr2("decoding into a slice, expect map/array - got ", ctyp.String())
-	}
-
-	if containerLenS == 0 {
-		if rvCanset {
-			if rvIsNil(rv) {
-				rvSetDirect(rv, rvSliceZeroCap(ti.rt))
-			} else {
-				rvSetSliceLen(rv, 0)
-			}
-		}
-		if isArray {
-			d.arrayEnd()
-		} else {
-			d.mapEnd()
-		}
-		return
-	}
-
-	rtelem0Mut := !scalarBitset.isset(ti.elemkind)
-	rtelem := ti.elem
-
-	for k := reflect.Kind(ti.elemkind); k == reflect.Ptr; k = rtelem.Kind() {
-		rtelem = rtelem.Elem()
-	}
-
-	var fn *decFnMsgpackBytes
-
-	var rvChanged bool
-
-	var rv0 = rv
-	var rv9 reflect.Value
-
-	rvlen := rvLenSlice(rv)
-	rvcap := rvCapSlice(rv)
-	maxInitLen := d.maxInitLen()
-	hasLen := containerLenS >= 0
-	if hasLen {
-		if containerLenS > rvcap {
-			oldRvlenGtZero := rvlen > 0
-			rvlen1 := int(decInferLen(containerLenS, maxInitLen, uint(ti.elemsize)))
-			if rvlen1 == rvlen {
-			} else if rvlen1 <= rvcap {
-				if rvCanset {
-					rvlen = rvlen1
-					rvSetSliceLen(rv, rvlen)
-				}
-			} else if rvCanset {
-				rvlen = rvlen1
-				rv, rvCanset = rvMakeSlice(rv, f.ti, rvlen, rvlen)
-				rvcap = rvlen
-				rvChanged = !rvCanset
-			} else {
-				halt.errorStr("cannot decode into non-settable slice")
-			}
-			if rvChanged && oldRvlenGtZero && rtelem0Mut {
-				rvCopySlice(rv, rv0, rtelem)
-			}
-		} else if containerLenS != rvlen {
-			if rvCanset {
-				rvlen = containerLenS
-				rvSetSliceLen(rv, rvlen)
-			}
-		}
-	}
-
-	var elemReset = d.h.SliceElementReset
-
-	var rtelemIsPtr bool
-	var rtelemElem reflect.Type
-	builtin := ti.tielem.flagDecBuiltin
-	if builtin {
-		rtelemIsPtr = ti.elemkind == uint8(reflect.Ptr)
-		if rtelemIsPtr {
-			rtelemElem = ti.elem.Elem()
-		}
-	}
-
-	var j int
-	for ; d.containerNext(j, containerLenS, hasLen); j++ {
-		if j == 0 {
-			if rvIsNil(rv) {
-				if rvCanset {
-					rvlen = int(decInferLen(containerLenS, maxInitLen, uint(ti.elemsize)))
-					rv, rvCanset = rvMakeSlice(rv, f.ti, rvlen, rvlen)
-					rvcap = rvlen
-					rvChanged = !rvCanset
-				} else {
-					halt.errorStr("cannot decode into non-settable slice")
-				}
-			}
-			if fn == nil {
-				fn = d.fn(rtelem)
-			}
-		}
-
-		if ctyp == valueTypeArray {
-			d.arrayElem(j == 0)
-		} else if j&1 == 0 {
-			d.mapElemKey(j == 0)
-		} else {
-			d.mapElemValue()
-		}
-
-		if j >= rvlen {
-
-			if rvlen < rvcap {
-				rvlen = rvcap
-				if rvCanset {
-					rvSetSliceLen(rv, rvlen)
-				} else if rvChanged {
-					rv = rvSlice(rv, rvlen)
-				} else {
-					halt.onerror(errExpandSliceCannotChange)
-				}
-			} else {
-				if !(rvCanset || rvChanged) {
-					halt.onerror(errExpandSliceCannotChange)
-				}
-				rv, rvcap, rvCanset = rvGrowSlice(rv, f.ti, rvcap, 1)
-
-				rvlen = rvcap
-				rvChanged = !rvCanset
-			}
-		}
-
-		rv9 = rvArrayIndex(rv, j, f.ti, true)
-		if elemReset {
-			rvSetZero(rv9)
-		}
-		if d.d.TryNil() {
-			rvSetZero(rv9)
-		} else if builtin {
-			if rtelemIsPtr {
-				if rvIsNil(rv9) {
-					rvSetDirect(rv9, reflect.New(rtelemElem))
-				}
-				d.decode(rv2i(rv9))
-			} else {
-				d.decode(rv2i(rvAddr(rv9, ti.tielem.ptr)))
-			}
-		} else {
-			d.decodeValueNoCheckNil(rv9, fn)
-		}
-	}
-	if j < rvlen {
-		if rvCanset {
-			rvSetSliceLen(rv, j)
-		} else if rvChanged {
-			rv = rvSlice(rv, j)
-		}
-
-	} else if j == 0 && rvIsNil(rv) {
-		if rvCanset {
-			rv = rvSliceZeroCap(ti.rt)
-			rvCanset = false
-			rvChanged = true
-		}
-	}
-	if isArray {
-		d.arrayEnd()
-	} else {
-		d.mapEnd()
-	}
-
-	if rvChanged {
-		rvSetDirect(rv0, rv)
-	}
-}
-
-func (d *decoderMsgpackBytes) kArray(f *decFnInfo, rv reflect.Value) {
-	_ = d.d
-
-	ti := f.ti
-	ctyp := d.d.ContainerType()
-	if handleBytesWithinKArray && (ctyp == valueTypeBytes || ctyp == valueTypeString) {
-
-		if ti.elemkind != uint8(reflect.Uint8) {
-			halt.errorf("bytes/string in stream can decode into array of bytes, but not %v", ti.rt)
-		}
-		rvbs := rvGetArrayBytes(rv, nil)
-		d.decodeBytesInto(rvbs, true)
-		return
-	}
-
-	var containerLenS int
-	isArray := ctyp == valueTypeArray
-	if isArray {
-		containerLenS = d.arrayStart(d.d.ReadArrayStart())
-	} else if ctyp == valueTypeMap {
-		containerLenS = d.mapStart(d.d.ReadMapStart()) * 2
-	} else {
-		halt.errorStr2("decoding into a slice, expect map/array - got ", ctyp.String())
-	}
-
-	if containerLenS == 0 {
-		if isArray {
-			d.arrayEnd()
-		} else {
-			d.mapEnd()
-		}
-		return
-	}
-
-	rtelem := ti.elem
-	for k := reflect.Kind(ti.elemkind); k == reflect.Ptr; k = rtelem.Kind() {
-		rtelem = rtelem.Elem()
-	}
-
-	var rv9 reflect.Value
-
-	rvlen := rv.Len()
-	hasLen := containerLenS >= 0
-	if hasLen && containerLenS > rvlen {
-		halt.errorf("cannot decode into array with length: %v, less than container length: %v", any(rvlen), any(containerLenS))
-	}
-
-	var elemReset = d.h.SliceElementReset
-
-	var rtelemIsPtr bool
-	var rtelemElem reflect.Type
-	var fn *decFnMsgpackBytes
-	builtin := ti.tielem.flagDecBuiltin
-	if builtin {
-		rtelemIsPtr = ti.elemkind == uint8(reflect.Ptr)
-		if rtelemIsPtr {
-			rtelemElem = ti.elem.Elem()
-		}
-	} else {
-		fn = d.fn(rtelem)
-	}
-
-	for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
-		if ctyp == valueTypeArray {
-			d.arrayElem(j == 0)
-		} else if j&1 == 0 {
-			d.mapElemKey(j == 0)
-		} else {
-			d.mapElemValue()
-		}
-
-		if j >= rvlen {
-			d.arrayCannotExpand(rvlen, j+1)
-			d.swallow()
-			continue
-		}
-
-		rv9 = rvArrayIndex(rv, j, f.ti, false)
-		if elemReset {
-			rvSetZero(rv9)
-		}
-		if d.d.TryNil() {
-			rvSetZero(rv9)
-		} else if builtin {
-			if rtelemIsPtr {
-				if rvIsNil(rv9) {
-					rvSetDirect(rv9, reflect.New(rtelemElem))
-				}
-				d.decode(rv2i(rv9))
-			} else {
-				d.decode(rv2i(rvAddr(rv9, ti.tielem.ptr)))
-			}
-		} else {
-			d.decodeValueNoCheckNil(rv9, fn)
-		}
-	}
-	if isArray {
-		d.arrayEnd()
-	} else {
-		d.mapEnd()
-	}
-}
-
-func (d *decoderMsgpackBytes) kChan(f *decFnInfo, rv reflect.Value) {
-	_ = d.d
-
-	ti := f.ti
-	if ti.chandir&uint8(reflect.SendDir) == 0 {
-		halt.errorStr("receive-only channel cannot be decoded")
-	}
-	ctyp := d.d.ContainerType()
-	if ctyp == valueTypeBytes || ctyp == valueTypeString {
-
-		if !(ti.rtid == uint8SliceTypId || ti.elemkind == uint8(reflect.Uint8)) {
-			halt.errorf("bytes/string in stream must decode into slice/array of bytes, not %v", ti.rt)
-		}
-		bs2, _ := d.d.DecodeBytes()
-		irv := rv2i(rv)
-		ch, ok := irv.(chan<- byte)
-		if !ok {
-			ch = irv.(chan byte)
-		}
-		for _, b := range bs2 {
-			ch <- b
-		}
-		return
-	}
-
-	var rvCanset = rv.CanSet()
-
-	var containerLenS int
-	isArray := ctyp == valueTypeArray
-	if isArray {
-		containerLenS = d.arrayStart(d.d.ReadArrayStart())
-	} else if ctyp == valueTypeMap {
-		containerLenS = d.mapStart(d.d.ReadMapStart()) * 2
-	} else {
-		halt.errorStr2("decoding into a slice, expect map/array - got ", ctyp.String())
-	}
-
-	if containerLenS == 0 {
-		if rvCanset && rvIsNil(rv) {
-			rvSetDirect(rv, reflect.MakeChan(ti.rt, 0))
-		}
-		if isArray {
-			d.arrayEnd()
-		} else {
-			d.mapEnd()
-		}
-		return
-	}
-
-	rtelem := ti.elem
-	useTransient := decUseTransient && ti.elemkind != byte(reflect.Ptr) && ti.tielem.flagCanTransient
-
-	for k := reflect.Kind(ti.elemkind); k == reflect.Ptr; k = rtelem.Kind() {
-		rtelem = rtelem.Elem()
-	}
-
-	var fn *decFnMsgpackBytes
-
-	var rvChanged bool
-	var rv0 = rv
-	var rv9 reflect.Value
-
-	var rvlen int
-	hasLen := containerLenS >= 0
-	maxInitLen := d.maxInitLen()
-
-	for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
-		if j == 0 {
-			if rvIsNil(rv) {
-				if hasLen {
-					rvlen = int(decInferLen(containerLenS, maxInitLen, uint(ti.elemsize)))
-				} else {
-					rvlen = decDefChanCap
-				}
-				if rvCanset {
-					rv = reflect.MakeChan(ti.rt, rvlen)
-					rvChanged = true
-				} else {
-					halt.errorStr("cannot decode into non-settable chan")
-				}
-			}
-			if fn == nil {
-				fn = d.fn(rtelem)
-			}
-		}
-
-		if ctyp == valueTypeArray {
-			d.arrayElem(j == 0)
-		} else if j&1 == 0 {
-			d.mapElemKey(j == 0)
-		} else {
-			d.mapElemValue()
-		}
-
-		if rv9.IsValid() {
-			rvSetZero(rv9)
-		} else if useTransient {
-			rv9 = d.perType.TransientAddrK(ti.elem, reflect.Kind(ti.elemkind))
-		} else {
-			rv9 = rvZeroAddrK(ti.elem, reflect.Kind(ti.elemkind))
-		}
-		if !d.d.TryNil() {
-			d.decodeValueNoCheckNil(rv9, fn)
-		}
-		rv.Send(rv9)
-	}
-	if isArray {
-		d.arrayEnd()
-	} else {
-		d.mapEnd()
-	}
-
-	if rvChanged {
-		rvSetDirect(rv0, rv)
-	}
-
-}
-
-func (d *decoderMsgpackBytes) kMap(f *decFnInfo, rv reflect.Value) {
-	_ = d.d
-	containerLen := d.mapStart(d.d.ReadMapStart())
-	ti := f.ti
-	if rvIsNil(rv) {
-		rvlen := int(decInferLen(containerLen, d.maxInitLen(), uint(ti.keysize+ti.elemsize)))
-		rvSetDirect(rv, makeMapReflect(ti.rt, rvlen))
-	}
-
-	if containerLen == 0 {
-		d.mapEnd()
-		return
-	}
-
-	ktype, vtype := ti.key, ti.elem
-	ktypeId := rt2id(ktype)
-	vtypeKind := reflect.Kind(ti.elemkind)
-	ktypeKind := reflect.Kind(ti.keykind)
-	mparams := getMapReqParams(ti)
-
-	vtypePtr := vtypeKind == reflect.Ptr
-	ktypePtr := ktypeKind == reflect.Ptr
-
-	vTransient := decUseTransient && !vtypePtr && ti.tielem.flagCanTransient
-
-	kTransient := vTransient && !ktypePtr && ti.tikey.flagCanTransient
-
-	var vtypeElem reflect.Type
-
-	var keyFn, valFn *decFnMsgpackBytes
-	var ktypeLo, vtypeLo = ktype, vtype
-
-	if ktypeKind == reflect.Ptr {
-		for ktypeLo = ktype.Elem(); ktypeLo.Kind() == reflect.Ptr; ktypeLo = ktypeLo.Elem() {
-		}
-	}
-
-	if vtypePtr {
-		vtypeElem = vtype.Elem()
-		for vtypeLo = vtypeElem; vtypeLo.Kind() == reflect.Ptr; vtypeLo = vtypeLo.Elem() {
-		}
-	}
-
-	rvkMut := !scalarBitset.isset(ti.keykind)
-	rvvMut := !scalarBitset.isset(ti.elemkind)
-	rvvCanNil := isnilBitset.isset(ti.elemkind)
-
-	var rvk, rvkn, rvv, rvvn, rvva, rvvz reflect.Value
-
-	var doMapGet, doMapSet bool
-
-	if !d.h.MapValueReset {
-		if rvvMut && (vtypeKind != reflect.Interface || !d.h.InterfaceReset) {
-			doMapGet = true
-			rvva = mapAddrLoopvarRV(vtype, vtypeKind)
-		}
-	}
-
-	ktypeIsString := ktypeId == stringTypId
-	ktypeIsIntf := ktypeId == intfTypId
-	hasLen := containerLen >= 0
-
-	var kstr2bs []byte
-	var kstr string
-
-	var mapKeyStringSharesBytesBuf bool
-	var att dBytesAttachState
-
-	var vElem, kElem reflect.Type
-	kbuiltin := ti.tikey.flagDecBuiltin && ti.keykind != uint8(reflect.Slice)
-	vbuiltin := ti.tielem.flagDecBuiltin
-	if kbuiltin && ktypePtr {
-		kElem = ti.key.Elem()
-	}
-	if vbuiltin && vtypePtr {
-		vElem = ti.elem.Elem()
-	}
-
-	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
-		mapKeyStringSharesBytesBuf = false
-		kstr = ""
-		if j == 0 {
-
-			if kTransient {
-				rvk = d.perType.TransientAddr2K(ktype, ktypeKind)
-			} else {
-				rvk = rvZeroAddrK(ktype, ktypeKind)
-			}
-			if !rvkMut {
-				rvkn = rvk
-			}
-			if !rvvMut {
-				if vTransient {
-					rvvn = d.perType.TransientAddrK(vtype, vtypeKind)
-				} else {
-					rvvn = rvZeroAddrK(vtype, vtypeKind)
-				}
-			}
-			if !ktypeIsString && keyFn == nil {
-				keyFn = d.fn(ktypeLo)
-			}
-			if valFn == nil {
-				valFn = d.fn(vtypeLo)
-			}
-		} else if rvkMut {
-			rvSetZero(rvk)
-		} else {
-			rvk = rvkn
-		}
-
-		d.mapElemKey(j == 0)
-
-		if d.d.TryNil() {
-			rvSetZero(rvk)
-		} else if ktypeIsString {
-			kstr2bs, att = d.d.DecodeStringAsBytes()
-			kstr, mapKeyStringSharesBytesBuf = d.bytes2Str(kstr2bs, att)
-			rvSetString(rvk, kstr)
-		} else {
-			if kbuiltin {
-				if ktypePtr {
-					if rvIsNil(rvk) {
-						rvSetDirect(rvk, reflect.New(kElem))
-					}
-					d.decode(rv2i(rvk))
-				} else {
-					d.decode(rv2i(rvAddr(rvk, ti.tikey.ptr)))
-				}
-			} else {
-				d.decodeValueNoCheckNil(rvk, keyFn)
-			}
-
-			if ktypeIsIntf {
-				if rvk2 := rvk.Elem(); rvk2.IsValid() && rvk2.Type() == uint8SliceTyp {
-					kstr2bs = rvGetBytes(rvk2)
-					kstr, mapKeyStringSharesBytesBuf = d.bytes2Str(kstr2bs, dBytesAttachView)
-					rvSetIntf(rvk, rv4istr(kstr))
-				}
-
-			}
-		}
-
-		if mapKeyStringSharesBytesBuf && d.bufio {
-			if ktypeIsString {
-				rvSetString(rvk, d.detach2Str(kstr2bs, att))
-			} else {
-				rvSetIntf(rvk, rv4istr(d.detach2Str(kstr2bs, att)))
-			}
-			mapKeyStringSharesBytesBuf = false
-		}
-
-		d.mapElemValue()
-
-		if d.d.TryNil() {
-			if mapKeyStringSharesBytesBuf {
-				if ktypeIsString {
-					rvSetString(rvk, d.detach2Str(kstr2bs, att))
-				} else {
-					rvSetIntf(rvk, rv4istr(d.detach2Str(kstr2bs, att)))
-				}
-			}
-
-			if !rvvz.IsValid() {
-				rvvz = rvZeroK(vtype, vtypeKind)
-			}
-			mapSet(rv, rvk, rvvz, mparams)
-			continue
-		}
-
-		doMapSet = true
-
-		if !rvvMut {
-			rvv = rvvn
-		} else if !doMapGet {
-			goto NEW_RVV
-		} else {
-			rvv = mapGet(rv, rvk, rvva, mparams)
-			if !rvv.IsValid() || (rvvCanNil && rvIsNil(rvv)) {
-				goto NEW_RVV
-			}
-			switch vtypeKind {
-			case reflect.Ptr, reflect.Map:
-				doMapSet = false
-			case reflect.Interface:
-
-				rvvn = rvv.Elem()
-				if k := rvvn.Kind(); (k == reflect.Ptr || k == reflect.Map) && !rvIsNil(rvvn) {
-					d.decodeValueNoCheckNil(rvvn, nil)
-					continue
-				}
-
-				rvvn = rvZeroAddrK(vtype, vtypeKind)
-				rvSetIntf(rvvn, rvv)
-				rvv = rvvn
-			default:
-
-				if vTransient {
-					rvvn = d.perType.TransientAddrK(vtype, vtypeKind)
-				} else {
-					rvvn = rvZeroAddrK(vtype, vtypeKind)
-				}
-				rvSetDirect(rvvn, rvv)
-				rvv = rvvn
-			}
-		}
-		goto DECODE_VALUE_NO_CHECK_NIL
-
-	NEW_RVV:
-		if vtypePtr {
-			rvv = reflect.New(vtypeElem)
-		} else if vTransient {
-			rvv = d.perType.TransientAddrK(vtype, vtypeKind)
-		} else {
-			rvv = rvZeroAddrK(vtype, vtypeKind)
-		}
-
-	DECODE_VALUE_NO_CHECK_NIL:
-		if doMapSet && mapKeyStringSharesBytesBuf {
-			if ktypeIsString {
-				rvSetString(rvk, d.detach2Str(kstr2bs, att))
-			} else {
-				rvSetIntf(rvk, rv4istr(d.detach2Str(kstr2bs, att)))
-			}
-		}
-		if vbuiltin {
-			if vtypePtr {
-				if rvIsNil(rvv) {
-					rvSetDirect(rvv, reflect.New(vElem))
-				}
-				d.decode(rv2i(rvv))
-			} else {
-				d.decode(rv2i(rvAddr(rvv, ti.tielem.ptr)))
-			}
-		} else {
-			d.decodeValueNoCheckNil(rvv, valFn)
-		}
-		if doMapSet {
-			mapSet(rv, rvk, rvv, mparams)
-		}
-	}
-
-	d.mapEnd()
-}
-
-func (d *decoderMsgpackBytes) init(h Handle) {
-	initHandle(h)
-	callMake(&d.d)
-	d.hh = h
-	d.h = h.getBasicHandle()
-
-	d.err = errDecoderNotInitialized
-
-	if d.h.InternString && d.is == nil {
-		d.is.init()
-	}
-
-	d.fp = d.d.init(h, &d.decoderBase, d).(*fastpathDsMsgpackBytes)
-
-	if d.bytes {
-		d.rtidFn = &d.h.rtidFnsDecBytes
-		d.rtidFnNoExt = &d.h.rtidFnsDecNoExtBytes
-	} else {
-		d.bufio = d.h.ReaderBufferSize > 0
-		d.rtidFn = &d.h.rtidFnsDecIO
-		d.rtidFnNoExt = &d.h.rtidFnsDecNoExtIO
-	}
-
-	d.reset()
-
-}
-
-func (d *decoderMsgpackBytes) reset() {
-	d.d.reset()
-	d.err = nil
-	d.c = 0
-	d.depth = 0
-	d.calls = 0
-
-	d.maxdepth = decDefMaxDepth
-	if d.h.MaxDepth > 0 {
-		d.maxdepth = d.h.MaxDepth
-	}
-	d.mtid = 0
-	d.stid = 0
-	d.mtr = false
-	d.str = false
-	if d.h.MapType != nil {
-		d.mtid = rt2id(d.h.MapType)
-		_, d.mtr = fastpathAvIndex(d.mtid)
-	}
-	if d.h.SliceType != nil {
-		d.stid = rt2id(d.h.SliceType)
-		_, d.str = fastpathAvIndex(d.stid)
-	}
-}
-
-func (d *decoderMsgpackBytes) Reset(r io.Reader) {
-	if d.bytes {
-		halt.onerror(errDecNoResetBytesWithReader)
-	}
-	d.reset()
-	if r == nil {
-		r = &eofReader
-	}
-	d.d.resetInIO(r)
-}
-
-func (d *decoderMsgpackBytes) ResetBytes(in []byte) {
-	if !d.bytes {
-		halt.onerror(errDecNoResetReaderWithBytes)
-	}
-	d.resetBytes(in)
-}
-
-func (d *decoderMsgpackBytes) resetBytes(in []byte) {
-	d.reset()
-	if in == nil {
-		in = zeroByteSlice
-	}
-	d.d.resetInBytes(in)
-}
-
-func (d *decoderMsgpackBytes) ResetString(s string) {
-	d.ResetBytes(bytesView(s))
-}
-
-func (d *decoderMsgpackBytes) Decode(v interface{}) (err error) {
-
-	defer panicValToErr(d, callRecoverSentinel, &d.err, &err, debugging)
-	d.mustDecode(v)
-	return
-}
-
-func (d *decoderMsgpackBytes) MustDecode(v interface{}) {
-	defer panicValToErr(d, callRecoverSentinel, &d.err, nil, true)
-	d.mustDecode(v)
-	return
-}
-
-func (d *decoderMsgpackBytes) mustDecode(v interface{}) {
-	halt.onerror(d.err)
-	if d.hh == nil {
-		halt.onerror(errNoFormatHandle)
-	}
-
-	d.calls++
-	d.decode(v)
-	d.calls--
-}
-
-func (d *decoderMsgpackBytes) Release() {}
-
-func (d *decoderMsgpackBytes) swallow() {
-	d.d.nextValueBytes()
-}
-
-func (d *decoderMsgpackBytes) nextValueBytes() []byte {
-	return d.d.nextValueBytes()
-}
-
-func (d *decoderMsgpackBytes) decode(iv interface{}) {
-	_ = d.d
-
-	rv, ok := isNil(iv, true)
-	if ok {
-		halt.onerror(errCannotDecodeIntoNil)
-	}
-
-	switch v := iv.(type) {
-
-	case *string:
-		*v = d.detach2Str(d.d.DecodeStringAsBytes())
-	case *bool:
-		*v = d.d.DecodeBool()
-	case *int:
-		*v = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
-	case *int8:
-		*v = int8(chkOvf.IntV(d.d.DecodeInt64(), 8))
-	case *int16:
-		*v = int16(chkOvf.IntV(d.d.DecodeInt64(), 16))
-	case *int32:
-		*v = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
-	case *int64:
-		*v = d.d.DecodeInt64()
-	case *uint:
-		*v = uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))
-	case *uint8:
-		*v = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
-	case *uint16:
-		*v = uint16(chkOvf.UintV(d.d.DecodeUint64(), 16))
-	case *uint32:
-		*v = uint32(chkOvf.UintV(d.d.DecodeUint64(), 32))
-	case *uint64:
-		*v = d.d.DecodeUint64()
-	case *uintptr:
-		*v = uintptr(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))
-	case *float32:
-		*v = d.d.DecodeFloat32()
-	case *float64:
-		*v = d.d.DecodeFloat64()
-	case *complex64:
-		*v = complex(d.d.DecodeFloat32(), 0)
-	case *complex128:
-		*v = complex(d.d.DecodeFloat64(), 0)
-	case *[]byte:
-		*v, _ = d.decodeBytesInto(*v, false)
-	case []byte:
-
-		d.decodeBytesInto(v[:len(v):len(v)], true)
-	case *time.Time:
-		*v = d.d.DecodeTime()
-	case *Raw:
-		*v = d.rawBytes()
-
-	case *interface{}:
-		d.decodeValue(rv4iptr(v), nil)
-
-	case reflect.Value:
-		if ok, _ = isDecodeable(v); !ok {
-			d.haltAsNotDecodeable(v)
-		}
-		d.decodeValue(v, nil)
-
-	default:
-
-		if skipFastpathTypeSwitchInDirectCall || !d.dh.fastpathDecodeTypeSwitch(iv, d) {
-			if !rv.IsValid() {
-				rv = reflect.ValueOf(iv)
-			}
-			if ok, _ = isDecodeable(rv); !ok {
-				d.haltAsNotDecodeable(rv)
-			}
-			d.decodeValue(rv, nil)
-		}
-	}
-}
-
-func (d *decoderMsgpackBytes) decodeValue(rv reflect.Value, fn *decFnMsgpackBytes) {
-	if d.d.TryNil() {
-		decSetNonNilRV2Zero(rv)
-	} else {
-		d.decodeValueNoCheckNil(rv, fn)
-	}
-}
-
-func (d *decoderMsgpackBytes) decodeValueNoCheckNil(rv reflect.Value, fn *decFnMsgpackBytes) {
-
-	var rvp reflect.Value
-	var rvpValid bool
-PTR:
-	if rv.Kind() == reflect.Ptr {
-		rvpValid = true
-		if rvIsNil(rv) {
-			rvSetDirect(rv, reflect.New(rv.Type().Elem()))
-		}
-		rvp = rv
-		rv = rv.Elem()
-		goto PTR
-	}
-
-	if fn == nil {
-		fn = d.fn(rv.Type())
-	}
-	if fn.i.addrD {
-		if rvpValid {
-			rv = rvp
-		} else if rv.CanAddr() {
-			rv = rvAddr(rv, fn.i.ti.ptr)
-		} else if fn.i.addrDf {
-			halt.errorStr("cannot decode into a non-pointer value")
-		}
-	}
-	fn.fd(d, &fn.i, rv)
-}
-
-func (d *decoderMsgpackBytes) decodeAs(v interface{}, t reflect.Type, ext bool) {
-	if ext {
-		d.decodeValue(baseRV(v), d.fn(t))
-	} else {
-		d.decodeValue(baseRV(v), d.fnNoExt(t))
-	}
-}
-
-func (d *decoderMsgpackBytes) structFieldNotFound(index int, rvkencname string) {
-
-	if d.h.ErrorIfNoField {
-		if index >= 0 {
-			halt.errorInt("no matching struct field found when decoding stream array at index ", int64(index))
-		} else if rvkencname != "" {
-			halt.errorStr2("no matching struct field found when decoding stream map with key ", rvkencname)
-		}
-	}
-	d.swallow()
-}
-
-func (d *decoderMsgpackBytes) decodeBytesInto(out []byte, mustFit bool) (v []byte, state dBytesIntoState) {
-	v, att := d.d.DecodeBytes()
-	if cap(v) == 0 || (att >= dBytesAttachViewZerocopy && !mustFit) {
-
-		return
-	}
-	if len(v) == 0 {
-		v = zeroByteSlice
-		return
-	}
-	if len(out) == len(v) {
-		state = dBytesIntoParamOut
-	} else if cap(out) >= len(v) {
-		out = out[:len(v)]
-		state = dBytesIntoParamOutSlice
-	} else if mustFit {
-		halt.errorf("bytes capacity insufficient for decoded bytes: got/expected: %d/%d", len(v), len(out))
-	} else {
-		out = make([]byte, len(v))
-		state = dBytesIntoNew
-	}
-	copy(out, v)
-	v = out
-	return
-}
-
-func (d *decoderMsgpackBytes) rawBytes() (v []byte) {
-
-	v = d.d.nextValueBytes()
-	if d.bytes && !d.h.ZeroCopy {
-		vv := make([]byte, len(v))
-		copy(vv, v)
-		v = vv
-	}
-	return
-}
-
-func (d *decoderMsgpackBytes) wrapErr(v error, err *error) {
-	*err = wrapCodecErr(v, d.hh.Name(), d.d.NumBytesRead(), false)
-}
-
-func (d *decoderMsgpackBytes) NumBytesRead() int {
-	return d.d.NumBytesRead()
-}
-
-func (d *decoderMsgpackBytes) containerNext(j, containerLen int, hasLen bool) bool {
-
-	if hasLen {
-		return j < containerLen
-	}
-	return !d.d.CheckBreak()
-}
-
-func (d *decoderMsgpackBytes) mapElemKey(firstTime bool) {
-	d.d.ReadMapElemKey(firstTime)
-	d.c = containerMapKey
-}
-
-func (d *decoderMsgpackBytes) mapElemValue() {
-	d.d.ReadMapElemValue()
-	d.c = containerMapValue
-}
-
-func (d *decoderMsgpackBytes) mapEnd() {
-	d.d.ReadMapEnd()
-	d.depthDecr()
-	d.c = 0
-}
-
-func (d *decoderMsgpackBytes) arrayElem(firstTime bool) {
-	d.d.ReadArrayElem(firstTime)
-	d.c = containerArrayElem
-}
-
-func (d *decoderMsgpackBytes) arrayEnd() {
-	d.d.ReadArrayEnd()
-	d.depthDecr()
-	d.c = 0
-}
-
-func (d *decoderMsgpackBytes) interfaceExtConvertAndDecode(v interface{}, ext InterfaceExt) {
-
-	var vv interface{}
-	d.decode(&vv)
-	ext.UpdateExt(v, vv)
-
-}
-
-func (d *decoderMsgpackBytes) fn(t reflect.Type) *decFnMsgpackBytes {
-	return d.dh.decFnViaBH(t, d.rtidFn, d.h, d.fp, false)
-}
-
-func (d *decoderMsgpackBytes) fnNoExt(t reflect.Type) *decFnMsgpackBytes {
-	return d.dh.decFnViaBH(t, d.rtidFnNoExt, d.h, d.fp, true)
-}
-
-func (helperDecDriverMsgpackBytes) newDecoderBytes(in []byte, h Handle) *decoderMsgpackBytes {
-	var c1 decoderMsgpackBytes
-	c1.bytes = true
-	c1.init(h)
-	c1.ResetBytes(in)
-	return &c1
-}
-
-func (helperDecDriverMsgpackBytes) newDecoderIO(in io.Reader, h Handle) *decoderMsgpackBytes {
-	var c1 decoderMsgpackBytes
-	c1.init(h)
-	c1.Reset(in)
-	return &c1
-}
-
-func (helperDecDriverMsgpackBytes) decFnloadFastpathUnderlying(ti *typeInfo, fp *fastpathDsMsgpackBytes) (f *fastpathDMsgpackBytes, u reflect.Type) {
-	rtid := rt2id(ti.fastpathUnderlying)
-	idx, ok := fastpathAvIndex(rtid)
-	if !ok {
-		return
-	}
-	f = &fp[idx]
-	if uint8(reflect.Array) == ti.kind {
-		u = reflect.ArrayOf(ti.rt.Len(), ti.elem)
-	} else {
-		u = f.rt
-	}
-	return
-}
-
-func (helperDecDriverMsgpackBytes) decFindRtidFn(s []decRtidFnMsgpackBytes, rtid uintptr) (i uint, fn *decFnMsgpackBytes) {
-
-	var h uint
-	var j = uint(len(s))
-LOOP:
-	if i < j {
-		h = (i + j) >> 1
-		if s[h].rtid < rtid {
-			i = h + 1
-		} else {
-			j = h
-		}
-		goto LOOP
-	}
-	if i < uint(len(s)) && s[i].rtid == rtid {
-		fn = s[i].fn
-	}
-	return
-}
-
-func (helperDecDriverMsgpackBytes) decFromRtidFnSlice(fns *atomicRtidFnSlice) (s []decRtidFnMsgpackBytes) {
-	if v := fns.load(); v != nil {
-		s = *(lowLevelToPtr[[]decRtidFnMsgpackBytes](v))
-	}
-	return
-}
-
-func (dh helperDecDriverMsgpackBytes) decFnViaBH(rt reflect.Type, fns *atomicRtidFnSlice, x *BasicHandle, fp *fastpathDsMsgpackBytes,
-	checkExt bool) (fn *decFnMsgpackBytes) {
-	return dh.decFnVia(rt, fns, x.typeInfos(), &x.mu, x.extHandle, fp,
-		checkExt, x.CheckCircularRef, x.timeBuiltin, x.binaryHandle, x.jsonHandle)
-}
-
-func (dh helperDecDriverMsgpackBytes) decFnVia(rt reflect.Type, fns *atomicRtidFnSlice,
-	tinfos *TypeInfos, mu *sync.Mutex, exth extHandle, fp *fastpathDsMsgpackBytes,
-	checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *decFnMsgpackBytes) {
-	rtid := rt2id(rt)
-	var sp []decRtidFnMsgpackBytes = dh.decFromRtidFnSlice(fns)
-	if sp != nil {
-		_, fn = dh.decFindRtidFn(sp, rtid)
-	}
-	if fn == nil {
-		fn = dh.decFnViaLoader(rt, rtid, fns, tinfos, mu, exth, fp, checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json)
-	}
-	return
-}
-
-func (dh helperDecDriverMsgpackBytes) decFnViaLoader(rt reflect.Type, rtid uintptr, fns *atomicRtidFnSlice,
-	tinfos *TypeInfos, mu *sync.Mutex, exth extHandle, fp *fastpathDsMsgpackBytes,
-	checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *decFnMsgpackBytes) {
-
-	fn = dh.decFnLoad(rt, rtid, tinfos, exth, fp, checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json)
-	var sp []decRtidFnMsgpackBytes
-	mu.Lock()
-	sp = dh.decFromRtidFnSlice(fns)
-
-	if sp == nil {
-		sp = []decRtidFnMsgpackBytes{{rtid, fn}}
-		fns.store(ptrToLowLevel(&sp))
-	} else {
-		idx, fn2 := dh.decFindRtidFn(sp, rtid)
-		if fn2 == nil {
-			sp2 := make([]decRtidFnMsgpackBytes, len(sp)+1)
-			copy(sp2[idx+1:], sp[idx:])
-			copy(sp2, sp[:idx])
-			sp2[idx] = decRtidFnMsgpackBytes{rtid, fn}
-			fns.store(ptrToLowLevel(&sp2))
-		}
-	}
-	mu.Unlock()
-	return
-}
-
-func (dh helperDecDriverMsgpackBytes) decFnLoad(rt reflect.Type, rtid uintptr, tinfos *TypeInfos,
-	exth extHandle, fp *fastpathDsMsgpackBytes,
-	checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *decFnMsgpackBytes) {
-	fn = new(decFnMsgpackBytes)
-	fi := &(fn.i)
-	ti := tinfos.get(rtid, rt)
-	fi.ti = ti
-	rk := reflect.Kind(ti.kind)
-
-	fi.addrDf = true
-
-	if rtid == timeTypId && timeBuiltin {
-		fn.fd = (*decoderMsgpackBytes).kTime
-	} else if rtid == rawTypId {
-		fn.fd = (*decoderMsgpackBytes).raw
-	} else if rtid == rawExtTypId {
-		fn.fd = (*decoderMsgpackBytes).rawExt
-		fi.addrD = true
-	} else if xfFn := exth.getExt(rtid, checkExt); xfFn != nil {
-		fi.xfTag, fi.xfFn = xfFn.tag, xfFn.ext
-		fn.fd = (*decoderMsgpackBytes).ext
-		fi.addrD = true
-	} else if ti.flagSelfer || ti.flagSelferPtr {
-		fn.fd = (*decoderMsgpackBytes).selferUnmarshal
-		fi.addrD = ti.flagSelferPtr
-	} else if supportMarshalInterfaces && binaryEncoding &&
-		(ti.flagBinaryMarshaler || ti.flagBinaryMarshalerPtr) &&
-		(ti.flagBinaryUnmarshaler || ti.flagBinaryUnmarshalerPtr) {
-		fn.fd = (*decoderMsgpackBytes).binaryUnmarshal
-		fi.addrD = ti.flagBinaryUnmarshalerPtr
-	} else if supportMarshalInterfaces && !binaryEncoding && json &&
-		(ti.flagJsonMarshaler || ti.flagJsonMarshalerPtr) &&
-		(ti.flagJsonUnmarshaler || ti.flagJsonUnmarshalerPtr) {
-
-		fn.fd = (*decoderMsgpackBytes).jsonUnmarshal
-		fi.addrD = ti.flagJsonUnmarshalerPtr
-	} else if supportMarshalInterfaces && !binaryEncoding &&
-		(ti.flagTextMarshaler || ti.flagTextMarshalerPtr) &&
-		(ti.flagTextUnmarshaler || ti.flagTextUnmarshalerPtr) {
-		fn.fd = (*decoderMsgpackBytes).textUnmarshal
-		fi.addrD = ti.flagTextUnmarshalerPtr
-	} else {
-		if fastpathEnabled && (rk == reflect.Map || rk == reflect.Slice || rk == reflect.Array) {
-			var rtid2 uintptr
-			if !ti.flagHasPkgPath {
-				rtid2 = rtid
-				if rk == reflect.Array {
-					rtid2 = rt2id(ti.key)
-				}
-				if idx, ok := fastpathAvIndex(rtid2); ok {
-					fn.fd = fp[idx].decfn
-					fi.addrD = true
-					fi.addrDf = false
-					if rk == reflect.Array {
-						fi.addrD = false
-					}
-				}
-			} else {
-
-				xfe, xrt := dh.decFnloadFastpathUnderlying(ti, fp)
-				if xfe != nil {
-					xfnf2 := xfe.decfn
-					if rk == reflect.Array {
-						fi.addrD = false
-						fn.fd = func(d *decoderMsgpackBytes, xf *decFnInfo, xrv reflect.Value) {
-							xfnf2(d, xf, rvConvert(xrv, xrt))
-						}
-					} else {
-						fi.addrD = true
-						fi.addrDf = false
-						xptr2rt := reflect.PointerTo(xrt)
-						fn.fd = func(d *decoderMsgpackBytes, xf *decFnInfo, xrv reflect.Value) {
-							if xrv.Kind() == reflect.Ptr {
-								xfnf2(d, xf, rvConvert(xrv, xptr2rt))
-							} else {
-								xfnf2(d, xf, rvConvert(xrv, xrt))
-							}
-						}
-					}
-				}
-			}
-		}
-		if fn.fd == nil {
-			switch rk {
-			case reflect.Bool:
-				fn.fd = (*decoderMsgpackBytes).kBool
-			case reflect.String:
-				fn.fd = (*decoderMsgpackBytes).kString
-			case reflect.Int:
-				fn.fd = (*decoderMsgpackBytes).kInt
-			case reflect.Int8:
-				fn.fd = (*decoderMsgpackBytes).kInt8
-			case reflect.Int16:
-				fn.fd = (*decoderMsgpackBytes).kInt16
-			case reflect.Int32:
-				fn.fd = (*decoderMsgpackBytes).kInt32
-			case reflect.Int64:
-				fn.fd = (*decoderMsgpackBytes).kInt64
-			case reflect.Uint:
-				fn.fd = (*decoderMsgpackBytes).kUint
-			case reflect.Uint8:
-				fn.fd = (*decoderMsgpackBytes).kUint8
-			case reflect.Uint16:
-				fn.fd = (*decoderMsgpackBytes).kUint16
-			case reflect.Uint32:
-				fn.fd = (*decoderMsgpackBytes).kUint32
-			case reflect.Uint64:
-				fn.fd = (*decoderMsgpackBytes).kUint64
-			case reflect.Uintptr:
-				fn.fd = (*decoderMsgpackBytes).kUintptr
-			case reflect.Float32:
-				fn.fd = (*decoderMsgpackBytes).kFloat32
-			case reflect.Float64:
-				fn.fd = (*decoderMsgpackBytes).kFloat64
-			case reflect.Complex64:
-				fn.fd = (*decoderMsgpackBytes).kComplex64
-			case reflect.Complex128:
-				fn.fd = (*decoderMsgpackBytes).kComplex128
-			case reflect.Chan:
-				fn.fd = (*decoderMsgpackBytes).kChan
-			case reflect.Slice:
-				fn.fd = (*decoderMsgpackBytes).kSlice
-			case reflect.Array:
-				fi.addrD = false
-				fn.fd = (*decoderMsgpackBytes).kArray
-			case reflect.Struct:
-				if ti.simple {
-					fn.fd = (*decoderMsgpackBytes).kStructSimple
-				} else {
-					fn.fd = (*decoderMsgpackBytes).kStruct
-				}
-			case reflect.Map:
-				fn.fd = (*decoderMsgpackBytes).kMap
-			case reflect.Interface:
-
-				fn.fd = (*decoderMsgpackBytes).kInterface
-			default:
-
-				fn.fd = (*decoderMsgpackBytes).kErr
-			}
-		}
-	}
-	return
-}
-func (e *msgpackEncDriverBytes) EncodeNil() {
-	e.w.writen1(mpNil)
-}
-
-func (e *msgpackEncDriverBytes) EncodeInt(i int64) {
-	if e.h.PositiveIntUnsigned && i >= 0 {
-		e.EncodeUint(uint64(i))
-	} else if i > math.MaxInt8 {
-		if i <= math.MaxInt16 {
-			e.w.writen1(mpInt16)
-			e.w.writen2(bigen.PutUint16(uint16(i)))
-		} else if i <= math.MaxInt32 {
-			e.w.writen1(mpInt32)
-			e.w.writen4(bigen.PutUint32(uint32(i)))
-		} else {
-			e.w.writen1(mpInt64)
-			e.w.writen8(bigen.PutUint64(uint64(i)))
-		}
-	} else if i >= -32 {
-		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 {
-		e.w.writen1(mpInt16)
-		e.w.writen2(bigen.PutUint16(uint16(i)))
-	} else if i >= math.MinInt32 {
-		e.w.writen1(mpInt32)
-		e.w.writen4(bigen.PutUint32(uint32(i)))
-	} else {
-		e.w.writen1(mpInt64)
-		e.w.writen8(bigen.PutUint64(uint64(i)))
-	}
-}
-
-func (e *msgpackEncDriverBytes) EncodeUint(i uint64) {
-	if i <= math.MaxInt8 {
-		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 {
-		e.w.writen1(mpUint16)
-		e.w.writen2(bigen.PutUint16(uint16(i)))
-	} else if i <= math.MaxUint32 {
-		e.w.writen1(mpUint32)
-		e.w.writen4(bigen.PutUint32(uint32(i)))
-	} else {
-		e.w.writen1(mpUint64)
-		e.w.writen8(bigen.PutUint64(uint64(i)))
-	}
-}
-
-func (e *msgpackEncDriverBytes) EncodeBool(b bool) {
-	if b {
-		e.w.writen1(mpTrue)
-	} else {
-		e.w.writen1(mpFalse)
-	}
-}
-
-func (e *msgpackEncDriverBytes) EncodeFloat32(f float32) {
-	e.w.writen1(mpFloat)
-	e.w.writen4(bigen.PutUint32(math.Float32bits(f)))
-}
-
-func (e *msgpackEncDriverBytes) EncodeFloat64(f float64) {
-	e.w.writen1(mpDouble)
-	e.w.writen8(bigen.PutUint64(math.Float64bits(f)))
-}
-
-func (e *msgpackEncDriverBytes) 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(msgpackContainerRawLegacy, l)
-	}
-	switch l {
-	case 4:
-		e.w.writen4(bigen.PutUint32(uint32(data64)))
-	case 8:
-		e.w.writen8(bigen.PutUint64(data64))
-	case 12:
-		e.w.writen4(bigen.PutUint32(uint32(nsec)))
-		e.w.writen8(bigen.PutUint64(uint64(sec)))
-	}
-}
-
-func (e *msgpackEncDriverBytes) EncodeExt(v interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
-	var bs0, bs []byte
-	if ext == SelfExt {
-		bs0 = e.e.blist.get(1024)
-		bs = bs0
-		sideEncode(e.h, &e.h.sideEncPool, func(se encoderI) { oneOffEncode(se, v, &bs, basetype, true) })
-	} else {
-		bs = ext.WriteExt(v)
-	}
-	if bs == nil {
-		e.writeNilBytes()
-		goto END
-	}
-	if e.h.WriteExt {
-		e.encodeExtPreamble(uint8(xtag), len(bs))
-		e.w.writeb(bs)
-	} else {
-		e.EncodeBytes(bs)
-	}
-END:
-	if ext == SelfExt {
-		e.e.blist.put(bs)
-		if !byteSliceSameData(bs0, bs) {
-			e.e.blist.put(bs0)
-		}
-	}
-}
-
-func (e *msgpackEncDriverBytes) EncodeRawExt(re *RawExt) {
-	e.encodeExtPreamble(uint8(re.Tag), len(re.Data))
-	e.w.writeb(re.Data)
-}
-
-func (e *msgpackEncDriverBytes) encodeExtPreamble(xtag byte, l int) {
-	if l == 1 {
-		e.w.writen2(mpFixExt1, xtag)
-	} else if l == 2 {
-		e.w.writen2(mpFixExt2, xtag)
-	} else if l == 4 {
-		e.w.writen2(mpFixExt4, xtag)
-	} else if l == 8 {
-		e.w.writen2(mpFixExt8, xtag)
-	} else if l == 16 {
-		e.w.writen2(mpFixExt16, xtag)
-	} else if l < 256 {
-		e.w.writen2(mpExt8, byte(l))
-		e.w.writen1(xtag)
-	} else if l < 65536 {
-		e.w.writen1(mpExt16)
-		e.w.writen2(bigen.PutUint16(uint16(l)))
-		e.w.writen1(xtag)
-	} else {
-		e.w.writen1(mpExt32)
-		e.w.writen4(bigen.PutUint32(uint32(l)))
-		e.w.writen1(xtag)
-	}
-}
-
-func (e *msgpackEncDriverBytes) WriteArrayStart(length int) {
-	e.writeContainerLen(msgpackContainerList, length)
-}
-
-func (e *msgpackEncDriverBytes) WriteMapStart(length int) {
-	e.writeContainerLen(msgpackContainerMap, length)
-}
-
-func (e *msgpackEncDriverBytes) WriteArrayEmpty() {
-
-	e.w.writen1(mpFixArrayMin)
-}
-
-func (e *msgpackEncDriverBytes) WriteMapEmpty() {
-
-	e.w.writen1(mpFixMapMin)
-}
-
-func (e *msgpackEncDriverBytes) EncodeString(s string) {
-	var ct msgpackContainerType
-	if e.h.WriteExt {
-		if e.h.StringToRaw {
-			ct = msgpackContainerBin
-		} else {
-			ct = msgpackContainerStr
-		}
-	} else {
-		ct = msgpackContainerRawLegacy
-	}
-	e.writeContainerLen(ct, len(s))
-	if len(s) > 0 {
-		e.w.writestr(s)
-	}
-}
-
-func (e *msgpackEncDriverBytes) EncodeStringNoEscape4Json(v string) { e.EncodeString(v) }
-
-func (e *msgpackEncDriverBytes) EncodeStringBytesRaw(bs []byte) {
-	if e.h.WriteExt {
-		e.writeContainerLen(msgpackContainerBin, len(bs))
-	} else {
-		e.writeContainerLen(msgpackContainerRawLegacy, len(bs))
-	}
-	if len(bs) > 0 {
-		e.w.writeb(bs)
-	}
-}
-
-func (e *msgpackEncDriverBytes) EncodeBytes(v []byte) {
-	if v == nil {
-		e.writeNilBytes()
-		return
-	}
-	e.EncodeStringBytesRaw(v)
-}
-
-func (e *msgpackEncDriverBytes) writeNilOr(v byte) {
-	if !e.h.NilCollectionToZeroLength {
-		v = mpNil
-	}
-	e.w.writen1(v)
-}
-
-func (e *msgpackEncDriverBytes) writeNilArray() {
-	e.writeNilOr(mpFixArrayMin)
-}
-
-func (e *msgpackEncDriverBytes) writeNilMap() {
-	e.writeNilOr(mpFixMapMin)
-}
-
-func (e *msgpackEncDriverBytes) writeNilBytes() {
-	e.writeNilOr(mpFixStrMin)
-}
-
-func (e *msgpackEncDriverBytes) writeContainerLen(ct msgpackContainerType, l int) {
-	if ct.fixCutoff > 0 && l < int(ct.fixCutoff) {
-		e.w.writen1(ct.bFixMin | byte(l))
-	} else if ct.b8 > 0 && l < 256 {
-		e.w.writen2(ct.b8, uint8(l))
-	} else if l < 65536 {
-		e.w.writen1(ct.b16)
-		e.w.writen2(bigen.PutUint16(uint16(l)))
-	} else {
-		e.w.writen1(ct.b32)
-		e.w.writen4(bigen.PutUint32(uint32(l)))
-	}
-}
-
-func (d *msgpackDecDriverBytes) DecodeNaked() {
-	if !d.bdRead {
-		d.readNextBd()
-	}
-	bd := d.bd
-	n := d.d.naked()
-	var decodeFurther bool
-
-	switch bd {
-	case mpNil:
-		n.v = valueTypeNil
-		d.bdRead = false
-	case mpFalse:
-		n.v = valueTypeBool
-		n.b = false
-	case mpTrue:
-		n.v = valueTypeBool
-		n.b = true
-
-	case mpFloat:
-		n.v = valueTypeFloat
-		n.f = float64(math.Float32frombits(bigen.Uint32(d.r.readn4())))
-	case mpDouble:
-		n.v = valueTypeFloat
-		n.f = math.Float64frombits(bigen.Uint64(d.r.readn8()))
-
-	case mpUint8:
-		n.v = valueTypeUint
-		n.u = uint64(d.r.readn1())
-	case mpUint16:
-		n.v = valueTypeUint
-		n.u = uint64(bigen.Uint16(d.r.readn2()))
-	case mpUint32:
-		n.v = valueTypeUint
-		n.u = uint64(bigen.Uint32(d.r.readn4()))
-	case mpUint64:
-		n.v = valueTypeUint
-		n.u = uint64(bigen.Uint64(d.r.readn8()))
-
-	case mpInt8:
-		n.v = valueTypeInt
-		n.i = int64(int8(d.r.readn1()))
-	case mpInt16:
-		n.v = valueTypeInt
-		n.i = int64(int16(bigen.Uint16(d.r.readn2())))
-	case mpInt32:
-		n.v = valueTypeInt
-		n.i = int64(int32(bigen.Uint32(d.r.readn4())))
-	case mpInt64:
-		n.v = valueTypeInt
-		n.i = int64(int64(bigen.Uint64(d.r.readn8())))
-
-	default:
-		switch {
-		case bd >= mpPosFixNumMin && bd <= mpPosFixNumMax:
-
-			n.v = valueTypeInt
-			n.i = int64(int8(bd))
-		case bd >= mpNegFixNumMin && bd <= mpNegFixNumMax:
-
-			n.v = valueTypeInt
-			n.i = int64(int8(bd))
-		case bd == mpStr8, bd == mpStr16, bd == mpStr32, bd >= mpFixStrMin && bd <= mpFixStrMax:
-			d.d.fauxUnionReadRawBytes(d, d.h.WriteExt, d.h.RawToString)
-
-		case bd == mpBin8, bd == mpBin16, bd == mpBin32:
-			d.d.fauxUnionReadRawBytes(d, false, d.h.RawToString)
-		case bd == mpArray16, bd == mpArray32, bd >= mpFixArrayMin && bd <= mpFixArrayMax:
-			n.v = valueTypeArray
-			decodeFurther = true
-		case bd == mpMap16, bd == mpMap32, bd >= mpFixMapMin && bd <= mpFixMapMax:
-			n.v = valueTypeMap
-			decodeFurther = true
-		case bd >= mpFixExt1 && bd <= mpFixExt16, bd >= mpExt8 && bd <= mpExt32:
-			n.v = valueTypeExt
-			clen := d.readExtLen()
-			n.u = uint64(d.r.readn1())
-			if n.u == uint64(mpTimeExtTagU) {
-				n.v = valueTypeTime
-				n.t = d.decodeTime(clen)
-			} else {
-				n.l = d.r.readx(uint(clen))
-			}
-		default:
-			halt.errorf("cannot infer value: %s: Ox%x/%d/%s", msgBadDesc, bd, bd, mpdesc(bd))
-		}
-	}
-	if !decodeFurther {
-		d.bdRead = false
-	}
-	if n.v == valueTypeUint && d.h.SignedInteger {
-		n.v = valueTypeInt
-		n.i = int64(n.u)
-	}
-}
-
-func (d *msgpackDecDriverBytes) nextValueBytes() (v []byte) {
-	if !d.bdRead {
-		d.readNextBd()
-	}
-	d.r.startRecording()
-	d.nextValueBytesBdReadR()
-	v = d.r.stopRecording()
-	d.bdRead = false
-	return
-}
-
-func (d *msgpackDecDriverBytes) nextValueBytesBdReadR() {
-	bd := d.bd
-
-	var clen uint
-
-	switch bd {
-	case mpNil, mpFalse, mpTrue:
-	case mpUint8, mpInt8:
-		d.r.readn1()
-	case mpUint16, mpInt16:
-		d.r.skip(2)
-	case mpFloat, mpUint32, mpInt32:
-		d.r.skip(4)
-	case mpDouble, mpUint64, mpInt64:
-		d.r.skip(8)
-	case mpStr8, mpBin8:
-		clen = uint(d.r.readn1())
-		d.r.skip(clen)
-	case mpStr16, mpBin16:
-		x := d.r.readn2()
-		clen = uint(bigen.Uint16(x))
-		d.r.skip(clen)
-	case mpStr32, mpBin32:
-		x := d.r.readn4()
-		clen = uint(bigen.Uint32(x))
-		d.r.skip(clen)
-	case mpFixExt1:
-		d.r.readn1()
-		d.r.readn1()
-	case mpFixExt2:
-		d.r.readn1()
-		d.r.skip(2)
-	case mpFixExt4:
-		d.r.readn1()
-		d.r.skip(4)
-	case mpFixExt8:
-		d.r.readn1()
-		d.r.skip(8)
-	case mpFixExt16:
-		d.r.readn1()
-		d.r.skip(16)
-	case mpExt8:
-		clen = uint(d.r.readn1())
-		d.r.readn1()
-		d.r.skip(clen)
-	case mpExt16:
-		x := d.r.readn2()
-		clen = uint(bigen.Uint16(x))
-		d.r.readn1()
-		d.r.skip(clen)
-	case mpExt32:
-		x := d.r.readn4()
-		clen = uint(bigen.Uint32(x))
-		d.r.readn1()
-		d.r.skip(clen)
-	case mpArray16:
-		x := d.r.readn2()
-		clen = uint(bigen.Uint16(x))
-		for i := uint(0); i < clen; i++ {
-			d.readNextBd()
-			d.nextValueBytesBdReadR()
-		}
-	case mpArray32:
-		x := d.r.readn4()
-		clen = uint(bigen.Uint32(x))
-		for i := uint(0); i < clen; i++ {
-			d.readNextBd()
-			d.nextValueBytesBdReadR()
-		}
-	case mpMap16:
-		x := d.r.readn2()
-		clen = uint(bigen.Uint16(x))
-		for i := uint(0); i < clen; i++ {
-			d.readNextBd()
-			d.nextValueBytesBdReadR()
-			d.readNextBd()
-			d.nextValueBytesBdReadR()
-		}
-	case mpMap32:
-		x := d.r.readn4()
-		clen = uint(bigen.Uint32(x))
-		for i := uint(0); i < clen; i++ {
-			d.readNextBd()
-			d.nextValueBytesBdReadR()
-			d.readNextBd()
-			d.nextValueBytesBdReadR()
-		}
-	default:
-		switch {
-		case bd >= mpPosFixNumMin && bd <= mpPosFixNumMax:
-		case bd >= mpNegFixNumMin && bd <= mpNegFixNumMax:
-		case bd >= mpFixStrMin && bd <= mpFixStrMax:
-			clen = uint(mpFixStrMin ^ bd)
-			d.r.skip(clen)
-		case bd >= mpFixArrayMin && bd <= mpFixArrayMax:
-			clen = uint(mpFixArrayMin ^ bd)
-			for i := uint(0); i < clen; i++ {
-				d.readNextBd()
-				d.nextValueBytesBdReadR()
-			}
-		case bd >= mpFixMapMin && bd <= mpFixMapMax:
-			clen = uint(mpFixMapMin ^ bd)
-			for i := uint(0); i < clen; i++ {
-				d.readNextBd()
-				d.nextValueBytesBdReadR()
-				d.readNextBd()
-				d.nextValueBytesBdReadR()
-			}
-		default:
-			halt.errorf("nextValueBytes: cannot infer value: %s: Ox%x/%d/%s", msgBadDesc, bd, bd, mpdesc(bd))
-		}
-	}
-	return
-}
-
-func (d *msgpackDecDriverBytes) decFloat4Int32() (f float32) {
-	fbits := bigen.Uint32(d.r.readn4())
-	f = math.Float32frombits(fbits)
-	if !noFrac32(fbits) {
-		halt.errorf("assigning integer value from float32 with a fraction: %v", f)
-	}
-	return
-}
-
-func (d *msgpackDecDriverBytes) decFloat4Int64() (f float64) {
-	fbits := bigen.Uint64(d.r.readn8())
-	f = math.Float64frombits(fbits)
-	if !noFrac64(fbits) {
-		halt.errorf("assigning integer value from float64 with a fraction: %v", f)
-	}
-	return
-}
-
-func (d *msgpackDecDriverBytes) DecodeInt64() (i int64) {
-	if d.advanceNil() {
-		return
-	}
-	switch d.bd {
-	case mpUint8:
-		i = int64(uint64(d.r.readn1()))
-	case mpUint16:
-		i = int64(uint64(bigen.Uint16(d.r.readn2())))
-	case mpUint32:
-		i = int64(uint64(bigen.Uint32(d.r.readn4())))
-	case mpUint64:
-		i = int64(bigen.Uint64(d.r.readn8()))
-	case mpInt8:
-		i = int64(int8(d.r.readn1()))
-	case mpInt16:
-		i = int64(int16(bigen.Uint16(d.r.readn2())))
-	case mpInt32:
-		i = int64(int32(bigen.Uint32(d.r.readn4())))
-	case mpInt64:
-		i = int64(bigen.Uint64(d.r.readn8()))
-	case mpFloat:
-		i = int64(d.decFloat4Int32())
-	case mpDouble:
-		i = int64(d.decFloat4Int64())
-	default:
-		switch {
-		case d.bd >= mpPosFixNumMin && d.bd <= mpPosFixNumMax:
-			i = int64(int8(d.bd))
-		case d.bd >= mpNegFixNumMin && d.bd <= mpNegFixNumMax:
-			i = int64(int8(d.bd))
-		default:
-			halt.errorf("cannot decode signed integer: %s: %x/%s", msgBadDesc, d.bd, mpdesc(d.bd))
-		}
-	}
-	d.bdRead = false
-	return
-}
-
-func (d *msgpackDecDriverBytes) DecodeUint64() (ui uint64) {
-	if d.advanceNil() {
-		return
-	}
-	switch d.bd {
-	case mpUint8:
-		ui = uint64(d.r.readn1())
-	case mpUint16:
-		ui = uint64(bigen.Uint16(d.r.readn2()))
-	case mpUint32:
-		ui = uint64(bigen.Uint32(d.r.readn4()))
-	case mpUint64:
-		ui = bigen.Uint64(d.r.readn8())
-	case mpInt8:
-		if i := int64(int8(d.r.readn1())); i >= 0 {
-			ui = uint64(i)
-		} else {
-			halt.errorf("assigning negative signed value: %v, to unsigned type", i)
-		}
-	case mpInt16:
-		if i := int64(int16(bigen.Uint16(d.r.readn2()))); i >= 0 {
-			ui = uint64(i)
-		} else {
-			halt.errorf("assigning negative signed value: %v, to unsigned type", i)
-		}
-	case mpInt32:
-		if i := int64(int32(bigen.Uint32(d.r.readn4()))); i >= 0 {
-			ui = uint64(i)
-		} else {
-			halt.errorf("assigning negative signed value: %v, to unsigned type", i)
-		}
-	case mpInt64:
-		if i := int64(bigen.Uint64(d.r.readn8())); i >= 0 {
-			ui = uint64(i)
-		} else {
-			halt.errorf("assigning negative signed value: %v, to unsigned type", i)
-		}
-	case mpFloat:
-		if f := d.decFloat4Int32(); f >= 0 {
-			ui = uint64(f)
-		} else {
-			halt.errorf("assigning negative float value: %v, to unsigned type", f)
-		}
-	case mpDouble:
-		if f := d.decFloat4Int64(); f >= 0 {
-			ui = uint64(f)
-		} else {
-			halt.errorf("assigning negative float value: %v, to unsigned type", f)
-		}
-	default:
-		switch {
-		case d.bd >= mpPosFixNumMin && d.bd <= mpPosFixNumMax:
-			ui = uint64(d.bd)
-		case d.bd >= mpNegFixNumMin && d.bd <= mpNegFixNumMax:
-			halt.errorf("assigning negative signed value: %v, to unsigned type", int(d.bd))
-		default:
-			halt.errorf("cannot decode unsigned integer: %s: %x/%s", msgBadDesc, d.bd, mpdesc(d.bd))
-		}
-	}
-	d.bdRead = false
-	return
-}
-
-func (d *msgpackDecDriverBytes) DecodeFloat64() (f float64) {
-	if d.advanceNil() {
-		return
-	}
-	if d.bd == mpFloat {
-		f = float64(math.Float32frombits(bigen.Uint32(d.r.readn4())))
-	} else if d.bd == mpDouble {
-		f = math.Float64frombits(bigen.Uint64(d.r.readn8()))
-	} else {
-		f = float64(d.DecodeInt64())
-	}
-	d.bdRead = false
-	return
-}
-
-func (d *msgpackDecDriverBytes) DecodeBool() (b bool) {
-	if d.advanceNil() {
-		return
-	}
-	if d.bd == mpFalse || d.bd == 0 {
-
-	} else if d.bd == mpTrue || d.bd == 1 {
-		b = true
-	} else {
-		halt.errorf("cannot decode bool: %s: %x/%s", msgBadDesc, d.bd, mpdesc(d.bd))
-	}
-	d.bdRead = false
-	return
-}
-
-func (d *msgpackDecDriverBytes) DecodeBytes() (bs []byte, state dBytesAttachState) {
-	if d.advanceNil() {
-		return
-	}
-
-	var cond bool
-	bd := d.bd
-	var clen int
-	if bd == mpBin8 || bd == mpBin16 || bd == mpBin32 {
-		clen = d.readContainerLen(msgpackContainerBin)
-	} else if bd == mpStr8 || bd == mpStr16 || bd == mpStr32 ||
-		(bd >= mpFixStrMin && bd <= mpFixStrMax) {
-		clen = d.readContainerLen(msgpackContainerStr)
-	} else if bd == mpArray16 || bd == mpArray32 ||
-		(bd >= mpFixArrayMin && bd <= mpFixArrayMax) {
-		slen := d.ReadArrayStart()
-		bs, cond = usableByteSlice(d.d.buf, slen)
-		for i := 0; i < len(bs); i++ {
-			bs[i] = uint8(chkOvf.UintV(d.DecodeUint64(), 8))
-		}
-		for i := len(bs); i < slen; i++ {
-			bs = append(bs, uint8(chkOvf.UintV(d.DecodeUint64(), 8)))
-		}
-		if cond {
-			d.d.buf = bs
-		}
-		state = dBytesAttachBuffer
-		return
-	} else {
-		halt.errorf("invalid byte descriptor for decoding bytes, got: 0x%x", d.bd)
-	}
-
-	d.bdRead = false
-	bs, cond = d.r.readxb(uint(clen))
-	state = d.d.attachState(cond)
-	return
-}
-
-func (d *msgpackDecDriverBytes) DecodeStringAsBytes() (out []byte, state dBytesAttachState) {
-	out, state = d.DecodeBytes()
-	if d.h.ValidateUnicode && !utf8.Valid(out) {
-		halt.errorf("DecodeStringAsBytes: invalid UTF-8: %s", out)
-	}
-	return
-}
-
-func (d *msgpackDecDriverBytes) readNextBd() {
-	d.bd = d.r.readn1()
-	d.bdRead = true
-}
-
-func (d *msgpackDecDriverBytes) advanceNil() (null bool) {
-	if !d.bdRead {
-		d.readNextBd()
-	}
-	if d.bd == mpNil {
-		d.bdRead = false
-		return true
-	}
-	return
-}
-
-func (d *msgpackDecDriverBytes) TryNil() (v bool) {
-	return d.advanceNil()
-}
-
-func (d *msgpackDecDriverBytes) ContainerType() (vt valueType) {
-	if !d.bdRead {
-		d.readNextBd()
-	}
-	bd := d.bd
-	if bd == mpNil {
-		d.bdRead = false
-		return valueTypeNil
-	} else if bd == mpBin8 || bd == mpBin16 || bd == mpBin32 {
-		return valueTypeBytes
-	} else if bd == mpStr8 || bd == mpStr16 || bd == mpStr32 ||
-		(bd >= mpFixStrMin && bd <= mpFixStrMax) {
-		if d.h.WriteExt || d.h.RawToString {
-			return valueTypeString
-		}
-		return valueTypeBytes
-	} else if bd == mpArray16 || bd == mpArray32 || (bd >= mpFixArrayMin && bd <= mpFixArrayMax) {
-		return valueTypeArray
-	} else if bd == mpMap16 || bd == mpMap32 || (bd >= mpFixMapMin && bd <= mpFixMapMax) {
-		return valueTypeMap
-	}
-	return valueTypeUnset
-}
-
-func (d *msgpackDecDriverBytes) readContainerLen(ct msgpackContainerType) (clen int) {
-	bd := d.bd
-	if bd == ct.b8 {
-		clen = int(d.r.readn1())
-	} else if bd == ct.b16 {
-		clen = int(bigen.Uint16(d.r.readn2()))
-	} else if bd == ct.b32 {
-		clen = int(bigen.Uint32(d.r.readn4()))
-	} else if (ct.bFixMin & bd) == ct.bFixMin {
-		clen = int(ct.bFixMin ^ bd)
-	} else {
-		halt.errorf("cannot read container length: %s: hex: %x, decimal: %d", msgBadDesc, bd, bd)
-	}
-	d.bdRead = false
-	return
-}
-
-func (d *msgpackDecDriverBytes) ReadMapStart() int {
-	if d.advanceNil() {
-		return containerLenNil
-	}
-	return d.readContainerLen(msgpackContainerMap)
-}
-
-func (d *msgpackDecDriverBytes) ReadArrayStart() int {
-	if d.advanceNil() {
-		return containerLenNil
-	}
-	return d.readContainerLen(msgpackContainerList)
-}
-
-func (d *msgpackDecDriverBytes) readExtLen() (clen int) {
-	switch d.bd {
-	case mpFixExt1:
-		clen = 1
-	case mpFixExt2:
-		clen = 2
-	case mpFixExt4:
-		clen = 4
-	case mpFixExt8:
-		clen = 8
-	case mpFixExt16:
-		clen = 16
-	case mpExt8:
-		clen = int(d.r.readn1())
-	case mpExt16:
-		clen = int(bigen.Uint16(d.r.readn2()))
-	case mpExt32:
-		clen = int(bigen.Uint32(d.r.readn4()))
-	default:
-		halt.errorf("decoding ext bytes: found unexpected byte: %x", d.bd)
-	}
-	return
-}
-
-func (d *msgpackDecDriverBytes) DecodeTime() (t time.Time) {
-
-	if d.advanceNil() {
-		return
-	}
-	bd := d.bd
-	var clen int
-	if bd == mpBin8 || bd == mpBin16 || bd == mpBin32 {
-		clen = d.readContainerLen(msgpackContainerBin)
-	} else if bd == mpStr8 || bd == mpStr16 || bd == mpStr32 ||
-		(bd >= mpFixStrMin && bd <= mpFixStrMax) {
-		clen = d.readContainerLen(msgpackContainerStr)
-	} else {
-
-		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 {
-			halt.errorf("invalid stream for decoding time as extension: got 0x%x, 0x%x", d.bd, b2)
-		}
-	}
-	return d.decodeTime(clen)
-}
-
-func (d *msgpackDecDriverBytes) decodeTime(clen int) (t time.Time) {
-	d.bdRead = false
-	switch clen {
-	case 4:
-		t = time.Unix(int64(bigen.Uint32(d.r.readn4())), 0).UTC()
-	case 8:
-		tv := bigen.Uint64(d.r.readn8())
-		t = time.Unix(int64(tv&0x00000003ffffffff), int64(tv>>34)).UTC()
-	case 12:
-		nsec := bigen.Uint32(d.r.readn4())
-		sec := bigen.Uint64(d.r.readn8())
-		t = time.Unix(int64(sec), int64(nsec)).UTC()
-	default:
-		halt.errorf("invalid length of bytes for decoding time - expecting 4 or 8 or 12, got %d", clen)
-	}
-	return
-}
-
-func (d *msgpackDecDriverBytes) DecodeExt(rv interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
-	xbs, _, _, ok := d.decodeExtV(ext != nil, xtag)
-	if !ok {
-		return
-	}
-	if ext == SelfExt {
-		sideDecode(d.h, &d.h.sideDecPool, func(sd decoderI) { oneOffDecode(sd, rv, xbs, basetype, true) })
-	} else {
-		ext.ReadExt(rv, xbs)
-	}
-}
-
-func (d *msgpackDecDriverBytes) DecodeRawExt(re *RawExt) {
-	xbs, realxtag, state, ok := d.decodeExtV(false, 0)
-	if !ok {
-		return
-	}
-	re.Tag = uint64(realxtag)
-	re.setData(xbs, state >= dBytesAttachViewZerocopy)
-}
-
-func (d *msgpackDecDriverBytes) decodeExtV(verifyTag bool, xtagIn uint64) (xbs []byte, xtag byte, bstate dBytesAttachState, ok bool) {
-	if xtagIn > 0xff {
-		halt.errorf("ext: tag must be <= 0xff; got: %v", xtagIn)
-	}
-	if d.advanceNil() {
-		return
-	}
-	tag := uint8(xtagIn)
-	xbd := d.bd
-	if xbd == mpBin8 || xbd == mpBin16 || xbd == mpBin32 {
-		xbs, bstate = d.DecodeBytes()
-	} else if xbd == mpStr8 || xbd == mpStr16 || xbd == mpStr32 ||
-		(xbd >= mpFixStrMin && xbd <= mpFixStrMax) {
-		xbs, bstate = d.DecodeStringAsBytes()
-	} else {
-		clen := d.readExtLen()
-		xtag = d.r.readn1()
-		if verifyTag && xtag != tag {
-			halt.errorf("wrong extension tag - got %b, expecting %v", xtag, tag)
-		}
-		xbs, ok = d.r.readxb(uint(clen))
-		bstate = d.d.attachState(ok)
-
-	}
-	d.bdRead = false
-	ok = true
-	return
-}
-
-func (d *msgpackEncDriverBytes) init(hh Handle, shared *encoderBase, enc encoderI) (fp interface{}) {
-	callMake(&d.w)
-	d.h = hh.(*MsgpackHandle)
-	d.e = shared
-	if shared.bytes {
-		fp = msgpackFpEncBytes
-	} else {
-		fp = msgpackFpEncIO
-	}
-
-	d.init2(enc)
-	return
-}
-
-func (e *msgpackEncDriverBytes) writeBytesAsis(b []byte) { e.w.writeb(b) }
-
-func (e *msgpackEncDriverBytes) writerEnd() { e.w.end() }
-
-func (e *msgpackEncDriverBytes) resetOutBytes(out *[]byte) {
-	e.w.resetBytes(*out, out)
-}
-
-func (e *msgpackEncDriverBytes) resetOutIO(out io.Writer) {
-	e.w.resetIO(out, e.h.WriterBufferSize, &e.e.blist)
-}
-
-func (d *msgpackDecDriverBytes) init(hh Handle, shared *decoderBase, dec decoderI) (fp interface{}) {
-	callMake(&d.r)
-	d.h = hh.(*MsgpackHandle)
-	d.d = shared
-	if shared.bytes {
-		fp = msgpackFpDecBytes
-	} else {
-		fp = msgpackFpDecIO
-	}
-
-	d.init2(dec)
-	return
-}
-
-func (d *msgpackDecDriverBytes) NumBytesRead() int {
-	return int(d.r.numread())
-}
-
-func (d *msgpackDecDriverBytes) resetInBytes(in []byte) {
-	d.r.resetBytes(in)
-}
-
-func (d *msgpackDecDriverBytes) resetInIO(r io.Reader) {
-	d.r.resetIO(r, d.h.ReaderBufferSize, d.h.MaxInitLen, &d.d.blist)
-}
-
-func (d *msgpackDecDriverBytes) descBd() string {
-	return sprintf("%v (%s)", d.bd, mpdesc(d.bd))
-}
-
-func (d *msgpackDecDriverBytes) DecodeFloat32() (f float32) {
-	return float32(chkOvf.Float32V(d.DecodeFloat64()))
-}
-
-type helperEncDriverMsgpackIO struct{}
-type encFnMsgpackIO struct {
-	i  encFnInfo
-	fe func(*encoderMsgpackIO, *encFnInfo, reflect.Value)
-}
-type encRtidFnMsgpackIO struct {
-	rtid uintptr
-	fn   *encFnMsgpackIO
-}
-type encoderMsgpackIO struct {
-	dh helperEncDriverMsgpackIO
-	fp *fastpathEsMsgpackIO
-	e  msgpackEncDriverIO
-	encoderBase
-}
-type helperDecDriverMsgpackIO struct{}
-type decFnMsgpackIO struct {
-	i  decFnInfo
-	fd func(*decoderMsgpackIO, *decFnInfo, reflect.Value)
-}
-type decRtidFnMsgpackIO struct {
-	rtid uintptr
-	fn   *decFnMsgpackIO
-}
-type decoderMsgpackIO struct {
-	dh helperDecDriverMsgpackIO
-	fp *fastpathDsMsgpackIO
-	d  msgpackDecDriverIO
-	decoderBase
-}
-type msgpackEncDriverIO struct {
-	noBuiltInTypes
-	encDriverNoopContainerWriter
-	encDriverNoState
-	encDriverContainerNoTrackerT
-	encInit2er
-
-	h *MsgpackHandle
-	e *encoderBase
-	w bufioEncWriter
-}
-type msgpackDecDriverIO struct {
-	decDriverNoopContainerReader
-	decDriverNoopNumberHelper
-	decInit2er
-
-	h *MsgpackHandle
-	d *decoderBase
-	r ioDecReader
-
-	bdAndBdread
-
-	noBuiltInTypes
-}
-
-func (e *encoderMsgpackIO) rawExt(_ *encFnInfo, rv reflect.Value) {
-	if re := rv2i(rv).(*RawExt); re == nil {
-		e.e.EncodeNil()
-	} else {
-		e.e.EncodeRawExt(re)
-	}
-}
-
-func (e *encoderMsgpackIO) ext(f *encFnInfo, rv reflect.Value) {
-	e.e.EncodeExt(rv2i(rv), f.ti.rt, f.xfTag, f.xfFn)
-}
-
-func (e *encoderMsgpackIO) selferMarshal(_ *encFnInfo, rv reflect.Value) {
-	rv2i(rv).(Selfer).CodecEncodeSelf(&Encoder{e})
-}
-
-func (e *encoderMsgpackIO) binaryMarshal(_ *encFnInfo, rv reflect.Value) {
-	bs, fnerr := rv2i(rv).(encoding.BinaryMarshaler).MarshalBinary()
-	e.marshalRaw(bs, fnerr)
-}
-
-func (e *encoderMsgpackIO) textMarshal(_ *encFnInfo, rv reflect.Value) {
-	bs, fnerr := rv2i(rv).(encoding.TextMarshaler).MarshalText()
-	e.marshalUtf8(bs, fnerr)
-}
-
-func (e *encoderMsgpackIO) jsonMarshal(_ *encFnInfo, rv reflect.Value) {
-	bs, fnerr := rv2i(rv).(jsonMarshaler).MarshalJSON()
-	e.marshalAsis(bs, fnerr)
-}
-
-func (e *encoderMsgpackIO) raw(_ *encFnInfo, rv reflect.Value) {
-	e.rawBytes(rv2i(rv).(Raw))
-}
-
-func (e *encoderMsgpackIO) encodeComplex64(v complex64) {
-	if imag(v) != 0 {
-		halt.errorf("cannot encode complex number: %v, with imaginary values: %v", any(v), any(imag(v)))
-	}
-	e.e.EncodeFloat32(real(v))
-}
-
-func (e *encoderMsgpackIO) encodeComplex128(v complex128) {
-	if imag(v) != 0 {
-		halt.errorf("cannot encode complex number: %v, with imaginary values: %v", any(v), any(imag(v)))
-	}
-	e.e.EncodeFloat64(real(v))
-}
-
-func (e *encoderMsgpackIO) kBool(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeBool(rvGetBool(rv))
-}
-
-func (e *encoderMsgpackIO) kTime(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeTime(rvGetTime(rv))
-}
-
-func (e *encoderMsgpackIO) kString(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeString(rvGetString(rv))
-}
-
-func (e *encoderMsgpackIO) kFloat32(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeFloat32(rvGetFloat32(rv))
-}
-
-func (e *encoderMsgpackIO) kFloat64(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeFloat64(rvGetFloat64(rv))
-}
-
-func (e *encoderMsgpackIO) kComplex64(_ *encFnInfo, rv reflect.Value) {
-	e.encodeComplex64(rvGetComplex64(rv))
-}
-
-func (e *encoderMsgpackIO) kComplex128(_ *encFnInfo, rv reflect.Value) {
-	e.encodeComplex128(rvGetComplex128(rv))
-}
-
-func (e *encoderMsgpackIO) kInt(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeInt(int64(rvGetInt(rv)))
-}
-
-func (e *encoderMsgpackIO) kInt8(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeInt(int64(rvGetInt8(rv)))
-}
-
-func (e *encoderMsgpackIO) kInt16(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeInt(int64(rvGetInt16(rv)))
-}
-
-func (e *encoderMsgpackIO) kInt32(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeInt(int64(rvGetInt32(rv)))
-}
-
-func (e *encoderMsgpackIO) kInt64(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeInt(int64(rvGetInt64(rv)))
-}
-
-func (e *encoderMsgpackIO) kUint(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeUint(uint64(rvGetUint(rv)))
-}
-
-func (e *encoderMsgpackIO) kUint8(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeUint(uint64(rvGetUint8(rv)))
-}
-
-func (e *encoderMsgpackIO) kUint16(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeUint(uint64(rvGetUint16(rv)))
-}
-
-func (e *encoderMsgpackIO) kUint32(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeUint(uint64(rvGetUint32(rv)))
-}
-
-func (e *encoderMsgpackIO) kUint64(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeUint(uint64(rvGetUint64(rv)))
-}
-
-func (e *encoderMsgpackIO) kUintptr(_ *encFnInfo, rv reflect.Value) {
-	e.e.EncodeUint(uint64(rvGetUintptr(rv)))
-}
-
-func (e *encoderMsgpackIO) kSeqFn(rt reflect.Type) (fn *encFnMsgpackIO) {
-
-	if rt = baseRT(rt); rt.Kind() != reflect.Interface {
-		fn = e.fn(rt)
-	}
-	return
-}
-
-func (e *encoderMsgpackIO) kArrayWMbs(rv reflect.Value, ti *typeInfo, isSlice bool) {
-	var l int
-	if isSlice {
-		l = rvLenSlice(rv)
-	} else {
-		l = rv.Len()
-	}
-	if l == 0 {
-		e.e.WriteMapEmpty()
-		return
-	}
-	e.haltOnMbsOddLen(l)
-	e.mapStart(l >> 1)
-
-	var fn *encFnMsgpackIO
-	builtin := ti.tielem.flagEncBuiltin
-	if !builtin {
-		fn = e.kSeqFn(ti.elem)
-	}
-
-	j := 0
-	e.c = containerMapKey
-	e.e.WriteMapElemKey(true)
-	for {
-		rvv := rvArrayIndex(rv, j, ti, isSlice)
-		if builtin {
-			e.encodeIB(rv2i(baseRVRV(rvv)))
-		} else {
-			e.encodeValue(rvv, fn)
-		}
-		j++
-		if j == l {
-			break
-		}
-		if j&1 == 0 {
-			e.c = containerMapKey
-			e.e.WriteMapElemKey(false)
-		} else {
-			e.mapElemValue()
-		}
-	}
-	e.c = 0
-	e.e.WriteMapEnd()
-
-}
-
-func (e *encoderMsgpackIO) kArrayW(rv reflect.Value, ti *typeInfo, isSlice bool) {
-	var l int
-	if isSlice {
-		l = rvLenSlice(rv)
-	} else {
-		l = rv.Len()
-	}
-	if l <= 0 {
-		e.e.WriteArrayEmpty()
-		return
-	}
-	e.arrayStart(l)
-
-	var fn *encFnMsgpackIO
-	if !ti.tielem.flagEncBuiltin {
-		fn = e.kSeqFn(ti.elem)
-	}
-
-	j := 0
-	e.c = containerArrayElem
-	e.e.WriteArrayElem(true)
-	builtin := ti.tielem.flagEncBuiltin
-	for {
-		rvv := rvArrayIndex(rv, j, ti, isSlice)
-		if builtin {
-			e.encodeIB(rv2i(baseRVRV(rvv)))
-		} else {
-			e.encodeValue(rvv, fn)
-		}
-		j++
-		if j == l {
-			break
-		}
-		e.c = containerArrayElem
-		e.e.WriteArrayElem(false)
-	}
-
-	e.c = 0
-	e.e.WriteArrayEnd()
-}
-
-func (e *encoderMsgpackIO) kChan(f *encFnInfo, rv reflect.Value) {
-	if f.ti.chandir&uint8(reflect.RecvDir) == 0 {
-		halt.errorStr("send-only channel cannot be encoded")
-	}
-	if !f.ti.mbs && uint8TypId == rt2id(f.ti.elem) {
-		e.kSliceBytesChan(rv)
-		return
-	}
-	rtslice := reflect.SliceOf(f.ti.elem)
-	rv = chanToSlice(rv, rtslice, e.h.ChanRecvTimeout)
-	ti := e.h.getTypeInfo(rt2id(rtslice), rtslice)
-	if f.ti.mbs {
-		e.kArrayWMbs(rv, ti, true)
-	} else {
-		e.kArrayW(rv, ti, true)
-	}
-}
-
-func (e *encoderMsgpackIO) kSlice(f *encFnInfo, rv reflect.Value) {
-	if f.ti.mbs {
-		e.kArrayWMbs(rv, f.ti, true)
-	} else if f.ti.rtid == uint8SliceTypId || uint8TypId == rt2id(f.ti.elem) {
-
-		e.e.EncodeBytes(rvGetBytes(rv))
-	} else {
-		e.kArrayW(rv, f.ti, true)
-	}
-}
-
-func (e *encoderMsgpackIO) kArray(f *encFnInfo, rv reflect.Value) {
-	if f.ti.mbs {
-		e.kArrayWMbs(rv, f.ti, false)
-	} else if handleBytesWithinKArray && uint8TypId == rt2id(f.ti.elem) {
-		e.e.EncodeStringBytesRaw(rvGetArrayBytes(rv, nil))
-	} else {
-		e.kArrayW(rv, f.ti, false)
-	}
-}
-
-func (e *encoderMsgpackIO) kSliceBytesChan(rv reflect.Value) {
-
-	bs0 := e.blist.peek(32, true)
-	bs := bs0
-
-	irv := rv2i(rv)
-	ch, ok := irv.(<-chan byte)
-	if !ok {
-		ch = irv.(chan byte)
-	}
-
-L1:
-	switch timeout := e.h.ChanRecvTimeout; {
-	case timeout == 0:
-		for {
-			select {
-			case b := <-ch:
-				bs = append(bs, b)
-			default:
-				break L1
-			}
-		}
-	case timeout > 0:
-		tt := time.NewTimer(timeout)
-		for {
-			select {
-			case b := <-ch:
-				bs = append(bs, b)
-			case <-tt.C:
-
-				break L1
-			}
-		}
-	default:
-		for b := range ch {
-			bs = append(bs, b)
-		}
-	}
-
-	e.e.EncodeBytes(bs)
-	e.blist.put(bs)
-	if !byteSliceSameData(bs0, bs) {
-		e.blist.put(bs0)
-	}
-}
-
-func (e *encoderMsgpackIO) kStructFieldKey(keyType valueType, encName string) {
-
-	if keyType == valueTypeString {
-		e.e.EncodeString(encName)
-	} else if keyType == valueTypeInt {
-		e.e.EncodeInt(must.Int(strconv.ParseInt(encName, 10, 64)))
-	} else if keyType == valueTypeUint {
-		e.e.EncodeUint(must.Uint(strconv.ParseUint(encName, 10, 64)))
-	} else if keyType == valueTypeFloat {
-		e.e.EncodeFloat64(must.Float(strconv.ParseFloat(encName, 64)))
-	} else {
-		halt.errorStr2("invalid struct key type: ", keyType.String())
-	}
-
-}
-
-func (e *encoderMsgpackIO) kStructSimple(f *encFnInfo, rv reflect.Value) {
-	_ = e.e
-	tisfi := f.ti.sfi.source()
-
-	chkCirRef := e.h.CheckCircularRef
-	var si *structFieldInfo
-	var j int
-
-	if f.ti.toArray || e.h.StructToArray {
-		if len(tisfi) == 0 {
-			e.e.WriteArrayEmpty()
-			return
-		}
-		e.arrayStart(len(tisfi))
-		for j, si = range tisfi {
-			e.c = containerArrayElem
-			e.e.WriteArrayElem(j == 0)
-			if si.encBuiltin {
-				e.encodeIB(rv2i(si.fieldNoAlloc(rv, true)))
-			} else {
-				e.encodeValue(si.fieldNoAlloc(rv, !chkCirRef), nil)
-			}
-		}
-		e.c = 0
-		e.e.WriteArrayEnd()
-	} else {
-		if len(tisfi) == 0 {
-			e.e.WriteMapEmpty()
-			return
-		}
-		if e.h.Canonical {
-			tisfi = f.ti.sfi.sorted()
-		}
-		e.mapStart(len(tisfi))
-		for j, si = range tisfi {
-			e.c = containerMapKey
-			e.e.WriteMapElemKey(j == 0)
-			e.e.EncodeStringNoEscape4Json(si.encName)
-			e.mapElemValue()
-			if si.encBuiltin {
-				e.encodeIB(rv2i(si.fieldNoAlloc(rv, true)))
-			} else {
-				e.encodeValue(si.fieldNoAlloc(rv, !chkCirRef), nil)
-			}
-		}
-		e.c = 0
-		e.e.WriteMapEnd()
-	}
-}
-
-func (e *encoderMsgpackIO) kStruct(f *encFnInfo, rv reflect.Value) {
-	_ = e.e
-	ti := f.ti
-	toMap := !(ti.toArray || e.h.StructToArray)
-	var mf map[string]interface{}
-	if ti.flagMissingFielder {
-		toMap = true
-		mf = rv2i(rv).(MissingFielder).CodecMissingFields()
-	} else if ti.flagMissingFielderPtr {
-		toMap = true
-		if rv.CanAddr() {
-			mf = rv2i(rvAddr(rv, ti.ptr)).(MissingFielder).CodecMissingFields()
-		} else {
-			mf = rv2i(e.addrRV(rv, ti.rt, ti.ptr)).(MissingFielder).CodecMissingFields()
-		}
-	}
-	newlen := len(mf)
-	tisfi := ti.sfi.source()
-	newlen += len(tisfi)
-
-	var fkvs = e.slist.get(newlen)[:newlen]
-
-	recur := e.h.RecursiveEmptyCheck
-	chkCirRef := e.h.CheckCircularRef
-
-	var xlen int
-
-	var kv sfiRv
-	var j int
-	var sf encStructFieldObj
-	if toMap {
-		newlen = 0
-		if e.h.Canonical {
-			tisfi = f.ti.sfi.sorted()
-		}
-		for _, si := range tisfi {
-
-			if si.omitEmpty {
-				kv.r = si.fieldNoAlloc(rv, false)
-				if isEmptyValue(kv.r, e.h.TypeInfos, recur) {
-					continue
-				}
-			} else {
-				kv.r = si.fieldNoAlloc(rv, si.encBuiltin || !chkCirRef)
-			}
-			kv.v = si
-			fkvs[newlen] = kv
-			newlen++
-		}
-
-		var mf2s []stringIntf
-		if len(mf) != 0 {
-			mf2s = make([]stringIntf, 0, len(mf))
-			for k, v := range mf {
-				if k == "" {
-					continue
-				}
-				if ti.infoFieldOmitempty && isEmptyValue(reflect.ValueOf(v), e.h.TypeInfos, recur) {
-					continue
-				}
-				mf2s = append(mf2s, stringIntf{k, v})
-			}
-		}
-
-		xlen = newlen + len(mf2s)
-		if xlen == 0 {
-			e.e.WriteMapEmpty()
-			goto END
-		}
-
-		e.mapStart(xlen)
-
-		if len(mf2s) != 0 && e.h.Canonical {
-			mf2w := make([]encStructFieldObj, newlen+len(mf2s))
-			for j = 0; j < newlen; j++ {
-				kv = fkvs[j]
-				mf2w[j] = encStructFieldObj{kv.v.encName, kv.r, nil, true,
-					!kv.v.encNameEscape4Json, kv.v.encBuiltin}
-			}
-			for _, v := range mf2s {
-				mf2w[j] = encStructFieldObj{v.v, reflect.Value{}, v.i, false, false, false}
-				j++
-			}
-			sort.Sort((encStructFieldObjSlice)(mf2w))
-			for j, sf = range mf2w {
-				e.c = containerMapKey
-				e.e.WriteMapElemKey(j == 0)
-				if ti.keyType == valueTypeString && sf.noEsc4json {
-					e.e.EncodeStringNoEscape4Json(sf.key)
-				} else {
-					e.kStructFieldKey(ti.keyType, sf.key)
-				}
-				e.mapElemValue()
-				if sf.isRv {
-					if sf.builtin {
-						e.encodeIB(rv2i(baseRVRV(sf.rv)))
-					} else {
-						e.encodeValue(sf.rv, nil)
-					}
-				} else {
-					if !e.encodeBuiltin(sf.intf) {
-						e.encodeR(reflect.ValueOf(sf.intf))
-					}
-
-				}
-			}
-		} else {
-			keytyp := ti.keyType
-			for j = 0; j < newlen; j++ {
-				kv = fkvs[j]
-				e.c = containerMapKey
-				e.e.WriteMapElemKey(j == 0)
-				if ti.keyType == valueTypeString && !kv.v.encNameEscape4Json {
-					e.e.EncodeStringNoEscape4Json(kv.v.encName)
-				} else {
-					e.kStructFieldKey(keytyp, kv.v.encName)
-				}
-				e.mapElemValue()
-				if kv.v.encBuiltin {
-					e.encodeIB(rv2i(baseRVRV(kv.r)))
-				} else {
-					e.encodeValue(kv.r, nil)
-				}
-			}
-			for _, v := range mf2s {
-				e.c = containerMapKey
-				e.e.WriteMapElemKey(j == 0)
-				e.kStructFieldKey(keytyp, v.v)
-				e.mapElemValue()
-				if !e.encodeBuiltin(v.i) {
-					e.encodeR(reflect.ValueOf(v.i))
-				}
-
-				j++
-			}
-		}
-
-		e.c = 0
-		e.e.WriteMapEnd()
-	} else {
-		newlen = len(tisfi)
-		for i, si := range tisfi {
-
-			if si.omitEmpty {
-
-				kv.r = si.fieldNoAlloc(rv, false)
-				if isEmptyContainerValue(kv.r, e.h.TypeInfos, recur) {
-					kv.r = reflect.Value{}
-				}
-			} else {
-				kv.r = si.fieldNoAlloc(rv, si.encBuiltin || !chkCirRef)
-			}
-			kv.v = si
-			fkvs[i] = kv
-		}
-
-		if newlen == 0 {
-			e.e.WriteArrayEmpty()
-			goto END
-		}
-
-		e.arrayStart(newlen)
-		for j = 0; j < newlen; j++ {
-			e.c = containerArrayElem
-			e.e.WriteArrayElem(j == 0)
-			kv = fkvs[j]
-			if !kv.r.IsValid() {
-				e.e.EncodeNil()
-			} else if kv.v.encBuiltin {
-				e.encodeIB(rv2i(baseRVRV(kv.r)))
-			} else {
-				e.encodeValue(kv.r, nil)
-			}
-		}
-		e.c = 0
-		e.e.WriteArrayEnd()
-	}
-
-END:
-
-	e.slist.put(fkvs)
-}
-
-func (e *encoderMsgpackIO) kMap(f *encFnInfo, rv reflect.Value) {
-	_ = e.e
-	l := rvLenMap(rv)
-	if l == 0 {
-		e.e.WriteMapEmpty()
-		return
-	}
-	e.mapStart(l)
-
-	var keyFn, valFn *encFnMsgpackIO
-
-	ktypeKind := reflect.Kind(f.ti.keykind)
-	vtypeKind := reflect.Kind(f.ti.elemkind)
-
-	rtval := f.ti.elem
-	rtvalkind := vtypeKind
-	for rtvalkind == reflect.Ptr {
-		rtval = rtval.Elem()
-		rtvalkind = rtval.Kind()
-	}
-	if rtvalkind != reflect.Interface {
-		valFn = e.fn(rtval)
-	}
-
-	var rvv = mapAddrLoopvarRV(f.ti.elem, vtypeKind)
-
-	rtkey := f.ti.key
-	var keyTypeIsString = stringTypId == rt2id(rtkey)
-	if keyTypeIsString {
-		keyFn = e.fn(rtkey)
-	} else {
-		for rtkey.Kind() == reflect.Ptr {
-			rtkey = rtkey.Elem()
-		}
-		if rtkey.Kind() != reflect.Interface {
-			keyFn = e.fn(rtkey)
-		}
-	}
-
-	if e.h.Canonical {
-		e.kMapCanonical(f.ti, rv, rvv, keyFn, valFn)
-		e.c = 0
-		e.e.WriteMapEnd()
-		return
-	}
-
-	var rvk = mapAddrLoopvarRV(f.ti.key, ktypeKind)
-
-	var it mapIter
-	mapRange(&it, rv, rvk, rvv, true)
-
-	kbuiltin := f.ti.tikey.flagEncBuiltin
-	vbuiltin := f.ti.tielem.flagEncBuiltin
-	for j := 0; it.Next(); j++ {
-		rv = it.Key()
-		e.c = containerMapKey
-		e.e.WriteMapElemKey(j == 0)
-		if keyTypeIsString {
-			e.e.EncodeString(rvGetString(rv))
-		} else if kbuiltin {
-			e.encodeIB(rv2i(baseRVRV(rv)))
-		} else {
-			e.encodeValue(rv, keyFn)
-		}
-		e.mapElemValue()
-		rv = it.Value()
-		if vbuiltin {
-			e.encodeIB(rv2i(baseRVRV(rv)))
-		} else {
-			e.encodeValue(it.Value(), valFn)
-		}
-	}
-	it.Done()
-
-	e.c = 0
-	e.e.WriteMapEnd()
-}
-
-func (e *encoderMsgpackIO) kMapCanonical(ti *typeInfo, rv, rvv reflect.Value, keyFn, valFn *encFnMsgpackIO) {
-	_ = e.e
-
-	rtkey := ti.key
-	rtkeydecl := rtkey.PkgPath() == "" && rtkey.Name() != ""
-
-	mks := rv.MapKeys()
-	rtkeyKind := rtkey.Kind()
-	mparams := getMapReqParams(ti)
-
-	switch rtkeyKind {
-	case reflect.Bool:
-
-		if len(mks) == 2 && mks[0].Bool() {
-			mks[0], mks[1] = mks[1], mks[0]
-		}
-		for i := range mks {
-			e.c = containerMapKey
-			e.e.WriteMapElemKey(i == 0)
-			if rtkeydecl {
-				e.e.EncodeBool(mks[i].Bool())
-			} else {
-				e.encodeValueNonNil(mks[i], keyFn)
-			}
-			e.mapElemValue()
-			e.encodeValue(mapGet(rv, mks[i], rvv, mparams), valFn)
-		}
-	case reflect.String:
-		mksv := make([]orderedRv[string], len(mks))
-		for i, k := range mks {
-			v := &mksv[i]
-			v.r = k
-			v.v = rvGetString(k)
-		}
-		slices.SortFunc(mksv, cmpOrderedRv)
-		for i := range mksv {
-			e.c = containerMapKey
-			e.e.WriteMapElemKey(i == 0)
-			if rtkeydecl {
-				e.e.EncodeString(mksv[i].v)
-			} else {
-				e.encodeValueNonNil(mksv[i].r, keyFn)
-			}
-			e.mapElemValue()
-			e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn)
-		}
-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint, reflect.Uintptr:
-		mksv := make([]orderedRv[uint64], len(mks))
-		for i, k := range mks {
-			v := &mksv[i]
-			v.r = k
-			v.v = k.Uint()
-		}
-		slices.SortFunc(mksv, cmpOrderedRv)
-		for i := range mksv {
-			e.c = containerMapKey
-			e.e.WriteMapElemKey(i == 0)
-			if rtkeydecl {
-				e.e.EncodeUint(mksv[i].v)
-			} else {
-				e.encodeValueNonNil(mksv[i].r, keyFn)
-			}
-			e.mapElemValue()
-			e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn)
-		}
-	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-		mksv := make([]orderedRv[int64], len(mks))
-		for i, k := range mks {
-			v := &mksv[i]
-			v.r = k
-			v.v = k.Int()
-		}
-		slices.SortFunc(mksv, cmpOrderedRv)
-		for i := range mksv {
-			e.c = containerMapKey
-			e.e.WriteMapElemKey(i == 0)
-			if rtkeydecl {
-				e.e.EncodeInt(mksv[i].v)
-			} else {
-				e.encodeValueNonNil(mksv[i].r, keyFn)
-			}
-			e.mapElemValue()
-			e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn)
-		}
-	case reflect.Float32:
-		mksv := make([]orderedRv[float64], len(mks))
-		for i, k := range mks {
-			v := &mksv[i]
-			v.r = k
-			v.v = k.Float()
-		}
-		slices.SortFunc(mksv, cmpOrderedRv)
-		for i := range mksv {
-			e.c = containerMapKey
-			e.e.WriteMapElemKey(i == 0)
-			if rtkeydecl {
-				e.e.EncodeFloat32(float32(mksv[i].v))
-			} else {
-				e.encodeValueNonNil(mksv[i].r, keyFn)
-			}
-			e.mapElemValue()
-			e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn)
-		}
-	case reflect.Float64:
-		mksv := make([]orderedRv[float64], len(mks))
-		for i, k := range mks {
-			v := &mksv[i]
-			v.r = k
-			v.v = k.Float()
-		}
-		slices.SortFunc(mksv, cmpOrderedRv)
-		for i := range mksv {
-			e.c = containerMapKey
-			e.e.WriteMapElemKey(i == 0)
-			if rtkeydecl {
-				e.e.EncodeFloat64(mksv[i].v)
-			} else {
-				e.encodeValueNonNil(mksv[i].r, keyFn)
-			}
-			e.mapElemValue()
-			e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn)
-		}
-	default:
-		if rtkey == timeTyp {
-			mksv := make([]timeRv, len(mks))
-			for i, k := range mks {
-				v := &mksv[i]
-				v.r = k
-				v.v = rv2i(k).(time.Time)
-			}
-			slices.SortFunc(mksv, cmpTimeRv)
-			for i := range mksv {
-				e.c = containerMapKey
-				e.e.WriteMapElemKey(i == 0)
-				e.e.EncodeTime(mksv[i].v)
-				e.mapElemValue()
-				e.encodeValue(mapGet(rv, mksv[i].r, rvv, mparams), valFn)
-			}
-			break
-		}
-
-		bs0 := e.blist.get(len(mks) * 16)
-		mksv := bs0
-		mksbv := make([]bytesRv, len(mks))
-
-		sideEncode(e.hh, &e.h.sideEncPool, func(se encoderI) {
-			se.ResetBytes(&mksv)
-			for i, k := range mks {
-				v := &mksbv[i]
-				l := len(mksv)
-				se.setContainerState(containerMapKey)
-				se.encodeR(baseRVRV(k))
-				se.atEndOfEncode()
-				se.writerEnd()
-				v.r = k
-				v.v = mksv[l:]
-			}
-		})
-
-		slices.SortFunc(mksbv, cmpBytesRv)
-		for j := range mksbv {
-			e.c = containerMapKey
-			e.e.WriteMapElemKey(j == 0)
-			e.e.writeBytesAsis(mksbv[j].v)
-			e.mapElemValue()
-			e.encodeValue(mapGet(rv, mksbv[j].r, rvv, mparams), valFn)
-		}
-		e.blist.put(mksv)
-		if !byteSliceSameData(bs0, mksv) {
-			e.blist.put(bs0)
-		}
-	}
-}
-
-func (e *encoderMsgpackIO) init(h Handle) {
-	initHandle(h)
-	callMake(&e.e)
-	e.hh = h
-	e.h = h.getBasicHandle()
-
-	e.err = errEncoderNotInitialized
-
-	e.fp = e.e.init(h, &e.encoderBase, e).(*fastpathEsMsgpackIO)
-
-	if e.bytes {
-		e.rtidFn = &e.h.rtidFnsEncBytes
-		e.rtidFnNoExt = &e.h.rtidFnsEncNoExtBytes
-	} else {
-		e.rtidFn = &e.h.rtidFnsEncIO
-		e.rtidFnNoExt = &e.h.rtidFnsEncNoExtIO
-	}
-
-	e.reset()
-}
-
-func (e *encoderMsgpackIO) reset() {
-	e.e.reset()
-	if e.ci != nil {
-		e.ci = e.ci[:0]
-	}
-	e.c = 0
-	e.calls = 0
-	e.seq = 0
-	e.err = nil
-}
-
-func (e *encoderMsgpackIO) Encode(v interface{}) (err error) {
-
-	defer panicValToErr(e, callRecoverSentinel, &e.err, &err, debugging)
-	e.mustEncode(v)
-	return
-}
-
-func (e *encoderMsgpackIO) MustEncode(v interface{}) {
-	defer panicValToErr(e, callRecoverSentinel, &e.err, nil, true)
-	e.mustEncode(v)
-	return
-}
-
-func (e *encoderMsgpackIO) mustEncode(v interface{}) {
-	halt.onerror(e.err)
-	if e.hh == nil {
-		halt.onerror(errNoFormatHandle)
-	}
-
-	e.calls++
-	if !e.encodeBuiltin(v) {
-		e.encodeR(reflect.ValueOf(v))
-	}
-
-	e.calls--
-	if e.calls == 0 {
-		e.e.atEndOfEncode()
-		e.e.writerEnd()
-	}
-}
-
-func (e *encoderMsgpackIO) encodeI(iv interface{}) {
-	if !e.encodeBuiltin(iv) {
-		e.encodeR(reflect.ValueOf(iv))
-	}
-}
-
-func (e *encoderMsgpackIO) encodeIB(iv interface{}) {
-	if !e.encodeBuiltin(iv) {
-
-		halt.errorStr("[should not happen] invalid type passed to encodeBuiltin")
-	}
-}
-
-func (e *encoderMsgpackIO) encodeR(base reflect.Value) {
-	e.encodeValue(base, nil)
-}
-
-func (e *encoderMsgpackIO) encodeBuiltin(iv interface{}) (ok bool) {
-	ok = true
-	switch v := iv.(type) {
-	case nil:
-		e.e.EncodeNil()
-
-	case Raw:
-		e.rawBytes(v)
-	case string:
-		e.e.EncodeString(v)
-	case bool:
-		e.e.EncodeBool(v)
-	case int:
-		e.e.EncodeInt(int64(v))
-	case int8:
-		e.e.EncodeInt(int64(v))
-	case int16:
-		e.e.EncodeInt(int64(v))
-	case int32:
-		e.e.EncodeInt(int64(v))
-	case int64:
-		e.e.EncodeInt(v)
-	case uint:
-		e.e.EncodeUint(uint64(v))
-	case uint8:
-		e.e.EncodeUint(uint64(v))
-	case uint16:
-		e.e.EncodeUint(uint64(v))
-	case uint32:
-		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 complex64:
-		e.encodeComplex64(v)
-	case complex128:
-		e.encodeComplex128(v)
-	case time.Time:
-		e.e.EncodeTime(v)
-	case []byte:
-		e.e.EncodeBytes(v)
-	default:
-
-		ok = !skipFastpathTypeSwitchInDirectCall && e.dh.fastpathEncodeTypeSwitch(iv, e)
-	}
-	return
-}
-
-func (e *encoderMsgpackIO) encodeValue(rv reflect.Value, fn *encFnMsgpackIO) {
-
-	var ciPushes int
-
-	var rvp reflect.Value
-	var rvpValid bool
-
-RV:
-	switch rv.Kind() {
-	case reflect.Ptr:
-		if rvIsNil(rv) {
-			e.e.EncodeNil()
-			goto END
-		}
-		rvpValid = true
-		rvp = rv
-		rv = rv.Elem()
-
-		if e.h.CheckCircularRef && e.ci.canPushElemKind(rv.Kind()) {
-			e.ci.push(rv2i(rvp))
-			ciPushes++
-		}
-		goto RV
-	case reflect.Interface:
-		if rvIsNil(rv) {
-			e.e.EncodeNil()
-			goto END
-		}
-		rvpValid = false
-		rvp = reflect.Value{}
-		rv = rv.Elem()
-		fn = nil
-		goto RV
-	case reflect.Map:
-		if rvIsNil(rv) {
-			if e.h.NilCollectionToZeroLength {
-				e.e.WriteMapEmpty()
-			} else {
-				e.e.EncodeNil()
-			}
-			goto END
-		}
-	case reflect.Slice, reflect.Chan:
-		if rvIsNil(rv) {
-			if e.h.NilCollectionToZeroLength {
-				e.e.WriteArrayEmpty()
-			} else {
-				e.e.EncodeNil()
-			}
-			goto END
-		}
-	case reflect.Invalid, reflect.Func:
-		e.e.EncodeNil()
-		goto END
-	}
-
-	if fn == nil {
-		fn = e.fn(rv.Type())
-	}
-
-	if !fn.i.addrE {
-
-	} else if rvpValid {
-		rv = rvp
-	} else if rv.CanAddr() {
-		rv = rvAddr(rv, fn.i.ti.ptr)
-	} else {
-		rv = e.addrRV(rv, fn.i.ti.rt, fn.i.ti.ptr)
-	}
-	fn.fe(e, &fn.i, rv)
-
-END:
-	if ciPushes > 0 {
-		e.ci.pop(ciPushes)
-	}
-}
-
-func (e *encoderMsgpackIO) encodeValueNonNil(rv reflect.Value, fn *encFnMsgpackIO) {
-
-	if fn.i.addrE {
-		if rv.CanAddr() {
-			rv = rvAddr(rv, fn.i.ti.ptr)
-		} else {
-			rv = e.addrRV(rv, fn.i.ti.rt, fn.i.ti.ptr)
-		}
-	}
-	fn.fe(e, &fn.i, rv)
-}
-
-func (e *encoderMsgpackIO) encodeAs(v interface{}, t reflect.Type, ext bool) {
-	if ext {
-		e.encodeValue(baseRV(v), e.fn(t))
-	} else {
-		e.encodeValue(baseRV(v), e.fnNoExt(t))
-	}
-}
-
-func (e *encoderMsgpackIO) marshalUtf8(bs []byte, fnerr error) {
-	halt.onerror(fnerr)
-	if bs == nil {
-		e.e.EncodeNil()
-	} else {
-		e.e.EncodeString(stringView(bs))
-	}
-}
-
-func (e *encoderMsgpackIO) marshalAsis(bs []byte, fnerr error) {
-	halt.onerror(fnerr)
-	if bs == nil {
-		e.e.EncodeNil()
-	} else {
-		e.e.writeBytesAsis(bs)
-	}
-}
-
-func (e *encoderMsgpackIO) marshalRaw(bs []byte, fnerr error) {
-	halt.onerror(fnerr)
-	e.e.EncodeBytes(bs)
-}
-
-func (e *encoderMsgpackIO) rawBytes(vv Raw) {
-	v := []byte(vv)
-	if !e.h.Raw {
-		halt.errorBytes("Raw values cannot be encoded: ", v)
-	}
-	e.e.writeBytesAsis(v)
-}
-
-func (e *encoderMsgpackIO) fn(t reflect.Type) *encFnMsgpackIO {
-	return e.dh.encFnViaBH(t, e.rtidFn, e.h, e.fp, false)
-}
-
-func (e *encoderMsgpackIO) fnNoExt(t reflect.Type) *encFnMsgpackIO {
-	return e.dh.encFnViaBH(t, e.rtidFnNoExt, e.h, e.fp, true)
-}
-
-func (e *encoderMsgpackIO) mapStart(length int) {
-	e.e.WriteMapStart(length)
-	e.c = containerMapStart
-}
-
-func (e *encoderMsgpackIO) mapElemValue() {
-	e.e.WriteMapElemValue()
-	e.c = containerMapValue
-}
-
-func (e *encoderMsgpackIO) arrayStart(length int) {
-	e.e.WriteArrayStart(length)
-	e.c = containerArrayStart
-}
-
-func (e *encoderMsgpackIO) writerEnd() {
-	e.e.writerEnd()
-}
-
-func (e *encoderMsgpackIO) atEndOfEncode() {
-	e.e.atEndOfEncode()
-}
-
-func (e *encoderMsgpackIO) Reset(w io.Writer) {
-	if e.bytes {
-		halt.onerror(errEncNoResetBytesWithWriter)
-	}
-	e.reset()
-	if w == nil {
-		w = io.Discard
-	}
-	e.e.resetOutIO(w)
-}
-
-func (e *encoderMsgpackIO) ResetBytes(out *[]byte) {
-	if !e.bytes {
-		halt.onerror(errEncNoResetWriterWithBytes)
-	}
-	e.resetBytes(out)
-}
-
-func (e *encoderMsgpackIO) resetBytes(out *[]byte) {
-	e.reset()
-	if out == nil {
-		out = &bytesEncAppenderDefOut
-	}
-	e.e.resetOutBytes(out)
-}
-
-func (helperEncDriverMsgpackIO) newEncoderBytes(out *[]byte, h Handle) *encoderMsgpackIO {
-	var c1 encoderMsgpackIO
-	c1.bytes = true
-	c1.init(h)
-	c1.ResetBytes(out)
-	return &c1
-}
-
-func (helperEncDriverMsgpackIO) newEncoderIO(out io.Writer, h Handle) *encoderMsgpackIO {
-	var c1 encoderMsgpackIO
-	c1.bytes = false
-	c1.init(h)
-	c1.Reset(out)
-	return &c1
-}
-
-func (helperEncDriverMsgpackIO) encFnloadFastpathUnderlying(ti *typeInfo, fp *fastpathEsMsgpackIO) (f *fastpathEMsgpackIO, u reflect.Type) {
-	rtid := rt2id(ti.fastpathUnderlying)
-	idx, ok := fastpathAvIndex(rtid)
-	if !ok {
-		return
-	}
-	f = &fp[idx]
-	if uint8(reflect.Array) == ti.kind {
-		u = reflect.ArrayOf(ti.rt.Len(), ti.elem)
-	} else {
-		u = f.rt
-	}
-	return
-}
-
-func (helperEncDriverMsgpackIO) encFindRtidFn(s []encRtidFnMsgpackIO, rtid uintptr) (i uint, fn *encFnMsgpackIO) {
-
-	var h uint
-	var j = uint(len(s))
-LOOP:
-	if i < j {
-		h = (i + j) >> 1
-		if s[h].rtid < rtid {
-			i = h + 1
-		} else {
-			j = h
-		}
-		goto LOOP
-	}
-	if i < uint(len(s)) && s[i].rtid == rtid {
-		fn = s[i].fn
-	}
-	return
-}
-
-func (helperEncDriverMsgpackIO) encFromRtidFnSlice(fns *atomicRtidFnSlice) (s []encRtidFnMsgpackIO) {
-	if v := fns.load(); v != nil {
-		s = *(lowLevelToPtr[[]encRtidFnMsgpackIO](v))
-	}
-	return
-}
-
-func (dh helperEncDriverMsgpackIO) encFnViaBH(rt reflect.Type, fns *atomicRtidFnSlice,
-	x *BasicHandle, fp *fastpathEsMsgpackIO, checkExt bool) (fn *encFnMsgpackIO) {
-	return dh.encFnVia(rt, fns, x.typeInfos(), &x.mu, x.extHandle, fp,
-		checkExt, x.CheckCircularRef, x.timeBuiltin, x.binaryHandle, x.jsonHandle)
-}
-
-func (dh helperEncDriverMsgpackIO) encFnVia(rt reflect.Type, fns *atomicRtidFnSlice,
-	tinfos *TypeInfos, mu *sync.Mutex, exth extHandle, fp *fastpathEsMsgpackIO,
-	checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *encFnMsgpackIO) {
-	rtid := rt2id(rt)
-	var sp []encRtidFnMsgpackIO = dh.encFromRtidFnSlice(fns)
-	if sp != nil {
-		_, fn = dh.encFindRtidFn(sp, rtid)
-	}
-	if fn == nil {
-		fn = dh.encFnViaLoader(rt, rtid, fns, tinfos, mu, exth, fp, checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json)
-	}
-	return
-}
-
-func (dh helperEncDriverMsgpackIO) encFnViaLoader(rt reflect.Type, rtid uintptr, fns *atomicRtidFnSlice,
-	tinfos *TypeInfos, mu *sync.Mutex, exth extHandle, fp *fastpathEsMsgpackIO,
-	checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *encFnMsgpackIO) {
-
-	fn = dh.encFnLoad(rt, rtid, tinfos, exth, fp, checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json)
-	var sp []encRtidFnMsgpackIO
-	mu.Lock()
-	sp = dh.encFromRtidFnSlice(fns)
-
-	if sp == nil {
-		sp = []encRtidFnMsgpackIO{{rtid, fn}}
-		fns.store(ptrToLowLevel(&sp))
-	} else {
-		idx, fn2 := dh.encFindRtidFn(sp, rtid)
-		if fn2 == nil {
-			sp2 := make([]encRtidFnMsgpackIO, len(sp)+1)
-			copy(sp2[idx+1:], sp[idx:])
-			copy(sp2, sp[:idx])
-			sp2[idx] = encRtidFnMsgpackIO{rtid, fn}
-			fns.store(ptrToLowLevel(&sp2))
-		}
-	}
-	mu.Unlock()
-	return
-}
-
-func (dh helperEncDriverMsgpackIO) encFnLoad(rt reflect.Type, rtid uintptr, tinfos *TypeInfos,
-	exth extHandle, fp *fastpathEsMsgpackIO,
-	checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *encFnMsgpackIO) {
-	fn = new(encFnMsgpackIO)
-	fi := &(fn.i)
-	ti := tinfos.get(rtid, rt)
-	fi.ti = ti
-	rk := reflect.Kind(ti.kind)
-
-	if rtid == timeTypId && timeBuiltin {
-		fn.fe = (*encoderMsgpackIO).kTime
-	} else if rtid == rawTypId {
-		fn.fe = (*encoderMsgpackIO).raw
-	} else if rtid == rawExtTypId {
-		fn.fe = (*encoderMsgpackIO).rawExt
-		fi.addrE = true
-	} else if xfFn := exth.getExt(rtid, checkExt); xfFn != nil {
-		fi.xfTag, fi.xfFn = xfFn.tag, xfFn.ext
-		fn.fe = (*encoderMsgpackIO).ext
-		if rk == reflect.Struct || rk == reflect.Array {
-			fi.addrE = true
-		}
-	} else if ti.flagSelfer || ti.flagSelferPtr {
-		fn.fe = (*encoderMsgpackIO).selferMarshal
-		fi.addrE = ti.flagSelferPtr
-	} else if supportMarshalInterfaces && binaryEncoding &&
-		(ti.flagBinaryMarshaler || ti.flagBinaryMarshalerPtr) &&
-		(ti.flagBinaryUnmarshaler || ti.flagBinaryUnmarshalerPtr) {
-		fn.fe = (*encoderMsgpackIO).binaryMarshal
-		fi.addrE = ti.flagBinaryMarshalerPtr
-	} else if supportMarshalInterfaces && !binaryEncoding && json &&
-		(ti.flagJsonMarshaler || ti.flagJsonMarshalerPtr) &&
-		(ti.flagJsonUnmarshaler || ti.flagJsonUnmarshalerPtr) {
-
-		fn.fe = (*encoderMsgpackIO).jsonMarshal
-		fi.addrE = ti.flagJsonMarshalerPtr
-	} else if supportMarshalInterfaces && !binaryEncoding &&
-		(ti.flagTextMarshaler || ti.flagTextMarshalerPtr) &&
-		(ti.flagTextUnmarshaler || ti.flagTextUnmarshalerPtr) {
-		fn.fe = (*encoderMsgpackIO).textMarshal
-		fi.addrE = ti.flagTextMarshalerPtr
-	} else {
-		if fastpathEnabled && (rk == reflect.Map || rk == reflect.Slice || rk == reflect.Array) {
-
-			var rtid2 uintptr
-			if !ti.flagHasPkgPath {
-				rtid2 = rtid
-				if rk == reflect.Array {
-					rtid2 = rt2id(ti.key)
-				}
-				if idx, ok := fastpathAvIndex(rtid2); ok {
-					fn.fe = fp[idx].encfn
-				}
-			} else {
-
-				xfe, xrt := dh.encFnloadFastpathUnderlying(ti, fp)
-				if xfe != nil {
-					xfnf := xfe.encfn
-					fn.fe = func(e *encoderMsgpackIO, xf *encFnInfo, xrv reflect.Value) {
-						xfnf(e, xf, rvConvert(xrv, xrt))
-					}
-				}
-			}
-		}
-		if fn.fe == nil {
-			switch rk {
-			case reflect.Bool:
-				fn.fe = (*encoderMsgpackIO).kBool
-			case reflect.String:
-
-				fn.fe = (*encoderMsgpackIO).kString
-			case reflect.Int:
-				fn.fe = (*encoderMsgpackIO).kInt
-			case reflect.Int8:
-				fn.fe = (*encoderMsgpackIO).kInt8
-			case reflect.Int16:
-				fn.fe = (*encoderMsgpackIO).kInt16
-			case reflect.Int32:
-				fn.fe = (*encoderMsgpackIO).kInt32
-			case reflect.Int64:
-				fn.fe = (*encoderMsgpackIO).kInt64
-			case reflect.Uint:
-				fn.fe = (*encoderMsgpackIO).kUint
-			case reflect.Uint8:
-				fn.fe = (*encoderMsgpackIO).kUint8
-			case reflect.Uint16:
-				fn.fe = (*encoderMsgpackIO).kUint16
-			case reflect.Uint32:
-				fn.fe = (*encoderMsgpackIO).kUint32
-			case reflect.Uint64:
-				fn.fe = (*encoderMsgpackIO).kUint64
-			case reflect.Uintptr:
-				fn.fe = (*encoderMsgpackIO).kUintptr
-			case reflect.Float32:
-				fn.fe = (*encoderMsgpackIO).kFloat32
-			case reflect.Float64:
-				fn.fe = (*encoderMsgpackIO).kFloat64
-			case reflect.Complex64:
-				fn.fe = (*encoderMsgpackIO).kComplex64
-			case reflect.Complex128:
-				fn.fe = (*encoderMsgpackIO).kComplex128
-			case reflect.Chan:
-				fn.fe = (*encoderMsgpackIO).kChan
-			case reflect.Slice:
-				fn.fe = (*encoderMsgpackIO).kSlice
-			case reflect.Array:
-				fn.fe = (*encoderMsgpackIO).kArray
-			case reflect.Struct:
-				if ti.simple {
-					fn.fe = (*encoderMsgpackIO).kStructSimple
-				} else {
-					fn.fe = (*encoderMsgpackIO).kStruct
-				}
-			case reflect.Map:
-				fn.fe = (*encoderMsgpackIO).kMap
-			case reflect.Interface:
-
-				fn.fe = (*encoderMsgpackIO).kErr
-			default:
-
-				fn.fe = (*encoderMsgpackIO).kErr
-			}
-		}
-	}
-	return
-}
-func (d *decoderMsgpackIO) rawExt(f *decFnInfo, rv reflect.Value) {
-	d.d.DecodeRawExt(rv2i(rv).(*RawExt))
-}
-
-func (d *decoderMsgpackIO) ext(f *decFnInfo, rv reflect.Value) {
-	d.d.DecodeExt(rv2i(rv), f.ti.rt, f.xfTag, f.xfFn)
-}
-
-func (d *decoderMsgpackIO) selferUnmarshal(_ *decFnInfo, rv reflect.Value) {
-	rv2i(rv).(Selfer).CodecDecodeSelf(&Decoder{d})
-}
-
-func (d *decoderMsgpackIO) binaryUnmarshal(_ *decFnInfo, rv reflect.Value) {
-	bm := rv2i(rv).(encoding.BinaryUnmarshaler)
-	xbs, _ := d.d.DecodeBytes()
-	fnerr := bm.UnmarshalBinary(xbs)
-	halt.onerror(fnerr)
-}
-
-func (d *decoderMsgpackIO) textUnmarshal(_ *decFnInfo, rv reflect.Value) {
-	tm := rv2i(rv).(encoding.TextUnmarshaler)
-	fnerr := tm.UnmarshalText(bytesOKs(d.d.DecodeStringAsBytes()))
-	halt.onerror(fnerr)
-}
-
-func (d *decoderMsgpackIO) jsonUnmarshal(_ *decFnInfo, rv reflect.Value) {
-	d.jsonUnmarshalV(rv2i(rv).(jsonUnmarshaler))
-}
-
-func (d *decoderMsgpackIO) jsonUnmarshalV(tm jsonUnmarshaler) {
-
-	halt.onerror(tm.UnmarshalJSON(d.d.nextValueBytes()))
-}
-
-func (d *decoderMsgpackIO) kErr(_ *decFnInfo, rv reflect.Value) {
-	halt.errorf("unsupported decoding kind: %s, for %#v", rv.Kind(), rv)
-
-}
-
-func (d *decoderMsgpackIO) raw(_ *decFnInfo, rv reflect.Value) {
-	rvSetBytes(rv, d.rawBytes())
-}
-
-func (d *decoderMsgpackIO) kString(_ *decFnInfo, rv reflect.Value) {
-	rvSetString(rv, d.detach2Str(d.d.DecodeStringAsBytes()))
-}
-
-func (d *decoderMsgpackIO) kBool(_ *decFnInfo, rv reflect.Value) {
-	rvSetBool(rv, d.d.DecodeBool())
-}
-
-func (d *decoderMsgpackIO) kTime(_ *decFnInfo, rv reflect.Value) {
-	rvSetTime(rv, d.d.DecodeTime())
-}
-
-func (d *decoderMsgpackIO) kFloat32(_ *decFnInfo, rv reflect.Value) {
-	rvSetFloat32(rv, d.d.DecodeFloat32())
-}
-
-func (d *decoderMsgpackIO) kFloat64(_ *decFnInfo, rv reflect.Value) {
-	rvSetFloat64(rv, d.d.DecodeFloat64())
-}
-
-func (d *decoderMsgpackIO) kComplex64(_ *decFnInfo, rv reflect.Value) {
-	rvSetComplex64(rv, complex(d.d.DecodeFloat32(), 0))
-}
-
-func (d *decoderMsgpackIO) kComplex128(_ *decFnInfo, rv reflect.Value) {
-	rvSetComplex128(rv, complex(d.d.DecodeFloat64(), 0))
-}
-
-func (d *decoderMsgpackIO) kInt(_ *decFnInfo, rv reflect.Value) {
-	rvSetInt(rv, int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize)))
-}
-
-func (d *decoderMsgpackIO) kInt8(_ *decFnInfo, rv reflect.Value) {
-	rvSetInt8(rv, int8(chkOvf.IntV(d.d.DecodeInt64(), 8)))
-}
-
-func (d *decoderMsgpackIO) kInt16(_ *decFnInfo, rv reflect.Value) {
-	rvSetInt16(rv, int16(chkOvf.IntV(d.d.DecodeInt64(), 16)))
-}
-
-func (d *decoderMsgpackIO) kInt32(_ *decFnInfo, rv reflect.Value) {
-	rvSetInt32(rv, int32(chkOvf.IntV(d.d.DecodeInt64(), 32)))
-}
-
-func (d *decoderMsgpackIO) kInt64(_ *decFnInfo, rv reflect.Value) {
-	rvSetInt64(rv, d.d.DecodeInt64())
-}
-
-func (d *decoderMsgpackIO) kUint(_ *decFnInfo, rv reflect.Value) {
-	rvSetUint(rv, uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize)))
-}
-
-func (d *decoderMsgpackIO) kUintptr(_ *decFnInfo, rv reflect.Value) {
-	rvSetUintptr(rv, uintptr(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize)))
-}
-
-func (d *decoderMsgpackIO) kUint8(_ *decFnInfo, rv reflect.Value) {
-	rvSetUint8(rv, uint8(chkOvf.UintV(d.d.DecodeUint64(), 8)))
-}
-
-func (d *decoderMsgpackIO) kUint16(_ *decFnInfo, rv reflect.Value) {
-	rvSetUint16(rv, uint16(chkOvf.UintV(d.d.DecodeUint64(), 16)))
-}
-
-func (d *decoderMsgpackIO) kUint32(_ *decFnInfo, rv reflect.Value) {
-	rvSetUint32(rv, uint32(chkOvf.UintV(d.d.DecodeUint64(), 32)))
-}
-
-func (d *decoderMsgpackIO) kUint64(_ *decFnInfo, rv reflect.Value) {
-	rvSetUint64(rv, d.d.DecodeUint64())
-}
-
-func (d *decoderMsgpackIO) kInterfaceNaked(f *decFnInfo) (rvn reflect.Value) {
-
-	n := d.naked()
-	d.d.DecodeNaked()
-
-	if decFailNonEmptyIntf && f.ti.numMeth > 0 {
-		halt.errorf("cannot decode non-nil codec value into nil %v (%v methods)", f.ti.rt, f.ti.numMeth)
-	}
-
-	switch n.v {
-	case valueTypeMap:
-		mtid := d.mtid
-		if mtid == 0 {
-			if d.jsms {
-				mtid = mapStrIntfTypId
-			} else {
-				mtid = mapIntfIntfTypId
-			}
-		}
-		if mtid == mapStrIntfTypId {
-			var v2 map[string]interface{}
-			d.decode(&v2)
-			rvn = rv4iptr(&v2).Elem()
-		} else if mtid == mapIntfIntfTypId {
-			var v2 map[interface{}]interface{}
-			d.decode(&v2)
-			rvn = rv4iptr(&v2).Elem()
-		} else if d.mtr {
-			rvn = reflect.New(d.h.MapType)
-			d.decode(rv2i(rvn))
-			rvn = rvn.Elem()
-		} else {
-
-			rvn = rvZeroAddrK(d.h.MapType, reflect.Map)
-			d.decodeValue(rvn, nil)
-		}
-	case valueTypeArray:
-		if d.stid == 0 || d.stid == intfSliceTypId {
-			var v2 []interface{}
-			d.decode(&v2)
-			rvn = rv4iptr(&v2).Elem()
-		} else if d.str {
-			rvn = reflect.New(d.h.SliceType)
-			d.decode(rv2i(rvn))
-			rvn = rvn.Elem()
-		} else {
-			rvn = rvZeroAddrK(d.h.SliceType, reflect.Slice)
-			d.decodeValue(rvn, nil)
-		}
-		if d.h.PreferArrayOverSlice {
-			rvn = rvGetArray4Slice(rvn)
-		}
-	case valueTypeExt:
-		tag, bytes := n.u, n.l
-		bfn := d.h.getExtForTag(tag)
-		var re = RawExt{Tag: tag}
-		if bytes == nil {
-
-			if bfn == nil {
-				d.decode(&re.Value)
-				rvn = rv4iptr(&re).Elem()
-			} else if bfn.ext == SelfExt {
-				rvn = rvZeroAddrK(bfn.rt, bfn.rt.Kind())
-				d.decodeValue(rvn, d.fnNoExt(bfn.rt))
-			} else {
-				rvn = reflect.New(bfn.rt)
-				d.interfaceExtConvertAndDecode(rv2i(rvn), bfn.ext)
-				rvn = rvn.Elem()
-			}
-		} else {
-
-			if bfn == nil {
-				re.setData(bytes, false)
-				rvn = rv4iptr(&re).Elem()
-			} else {
-				rvn = reflect.New(bfn.rt)
-				if bfn.ext == SelfExt {
-					sideDecode(d.hh, &d.h.sideDecPool, func(sd decoderI) { oneOffDecode(sd, rv2i(rvn), bytes, bfn.rt, true) })
-				} else {
-					bfn.ext.ReadExt(rv2i(rvn), bytes)
-				}
-				rvn = rvn.Elem()
-			}
-		}
-
-		if d.h.PreferPointerForStructOrArray && rvn.CanAddr() {
-			if rk := rvn.Kind(); rk == reflect.Array || rk == reflect.Struct {
-				rvn = rvn.Addr()
-			}
-		}
-	case valueTypeNil:
-
-	case valueTypeInt:
-		rvn = n.ri()
-	case valueTypeUint:
-		rvn = n.ru()
-	case valueTypeFloat:
-		rvn = n.rf()
-	case valueTypeBool:
-		rvn = n.rb()
-	case valueTypeString, valueTypeSymbol:
-		rvn = n.rs()
-	case valueTypeBytes:
-		rvn = n.rl()
-	case valueTypeTime:
-		rvn = n.rt()
-	default:
-		halt.errorStr2("kInterfaceNaked: unexpected valueType: ", n.v.String())
-	}
-	return
-}
-
-func (d *decoderMsgpackIO) kInterface(f *decFnInfo, rv reflect.Value) {
-
-	isnilrv := rvIsNil(rv)
-
-	var rvn reflect.Value
-
-	if d.h.InterfaceReset {
-
-		rvn = d.h.intf2impl(f.ti.rtid)
-		if !rvn.IsValid() {
-			rvn = d.kInterfaceNaked(f)
-			if rvn.IsValid() {
-				rvSetIntf(rv, rvn)
-			} else if !isnilrv {
-				decSetNonNilRV2Zero4Intf(rv)
-			}
-			return
-		}
-	} else if isnilrv {
-
-		rvn = d.h.intf2impl(f.ti.rtid)
-		if !rvn.IsValid() {
-			rvn = d.kInterfaceNaked(f)
-			if rvn.IsValid() {
-				rvSetIntf(rv, rvn)
-			}
-			return
-		}
-	} else {
-
-		rvn = rv.Elem()
-	}
-
-	canDecode, _ := isDecodeable(rvn)
-
-	if !canDecode {
-		rvn2 := d.oneShotAddrRV(rvn.Type(), rvn.Kind())
-		rvSetDirect(rvn2, rvn)
-		rvn = rvn2
-	}
-
-	d.decodeValue(rvn, nil)
-	rvSetIntf(rv, rvn)
-}
-
-func (d *decoderMsgpackIO) kStructField(si *structFieldInfo, rv reflect.Value) {
-	if d.d.TryNil() {
-		rv = si.fieldNoAlloc(rv, true)
-		if rv.IsValid() {
-			decSetNonNilRV2Zero(rv)
-		}
-	} else if si.decBuiltin {
-		rv = rvAddr(si.fieldAlloc(rv), si.ptrTyp)
-		d.decode(rv2i(rv))
-	} else {
-		fn := d.fn(si.baseTyp)
-		rv = si.fieldAlloc(rv)
-		if fn.i.addrD {
-			rv = rvAddr(rv, si.ptrTyp)
-		}
-		fn.fd(d, &fn.i, rv)
-	}
-}
-
-func (d *decoderMsgpackIO) kStructSimple(f *decFnInfo, rv reflect.Value) {
-	_ = d.d
-	ctyp := d.d.ContainerType()
-	ti := f.ti
-	if ctyp == valueTypeMap {
-		containerLen := d.mapStart(d.d.ReadMapStart())
-		if containerLen == 0 {
-			d.mapEnd()
-			return
-		}
-		hasLen := containerLen >= 0
-		var rvkencname []byte
-		for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
-			d.mapElemKey(j == 0)
-			sab, att := d.d.DecodeStringAsBytes()
-			rvkencname = d.usableStructFieldNameBytes(rvkencname, sab, att)
-			d.mapElemValue()
-			if si := ti.siForEncName(rvkencname); si != nil {
-				d.kStructField(si, rv)
-			} else {
-				d.structFieldNotFound(-1, stringView(rvkencname))
-			}
-		}
-		d.mapEnd()
-	} else if ctyp == valueTypeArray {
-		containerLen := d.arrayStart(d.d.ReadArrayStart())
-		if containerLen == 0 {
-			d.arrayEnd()
-			return
-		}
-
-		tisfi := ti.sfi.source()
-		hasLen := containerLen >= 0
-
-		for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
-			d.arrayElem(j == 0)
-			if j < len(tisfi) {
-				d.kStructField(tisfi[j], rv)
-			} else {
-				d.structFieldNotFound(j, "")
-			}
-		}
-		d.arrayEnd()
-	} else {
-		halt.onerror(errNeedMapOrArrayDecodeToStruct)
-	}
-}
-
-func (d *decoderMsgpackIO) kStruct(f *decFnInfo, rv reflect.Value) {
-	_ = d.d
-	ctyp := d.d.ContainerType()
-	ti := f.ti
-	var mf MissingFielder
-	if ti.flagMissingFielder {
-		mf = rv2i(rv).(MissingFielder)
-	} else if ti.flagMissingFielderPtr {
-		mf = rv2i(rvAddr(rv, ti.ptr)).(MissingFielder)
-	}
-	if ctyp == valueTypeMap {
-		containerLen := d.mapStart(d.d.ReadMapStart())
-		if containerLen == 0 {
-			d.mapEnd()
-			return
-		}
-		hasLen := containerLen >= 0
-		var name2 []byte
-		var rvkencname []byte
-		tkt := ti.keyType
-		for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
-			d.mapElemKey(j == 0)
-
-			if tkt == valueTypeString {
-				sab, att := d.d.DecodeStringAsBytes()
-				rvkencname = d.usableStructFieldNameBytes(rvkencname, sab, att)
-			} else if tkt == valueTypeInt {
-				rvkencname = strconv.AppendInt(d.b[:0], d.d.DecodeInt64(), 10)
-			} else if tkt == valueTypeUint {
-				rvkencname = strconv.AppendUint(d.b[:0], d.d.DecodeUint64(), 10)
-			} else if tkt == valueTypeFloat {
-				rvkencname = strconv.AppendFloat(d.b[:0], d.d.DecodeFloat64(), 'f', -1, 64)
-			} else {
-				halt.errorStr2("invalid struct key type: ", ti.keyType.String())
-			}
-
-			d.mapElemValue()
-			if si := ti.siForEncName(rvkencname); si != nil {
-				d.kStructField(si, rv)
-			} else if mf != nil {
-
-				name2 = append(name2[:0], rvkencname...)
-				var f interface{}
-				d.decode(&f)
-				if !mf.CodecMissingField(name2, f) && d.h.ErrorIfNoField {
-					halt.errorStr2("no matching struct field when decoding stream map with key: ", stringView(name2))
-				}
-			} else {
-				d.structFieldNotFound(-1, stringView(rvkencname))
-			}
-		}
-		d.mapEnd()
-	} else if ctyp == valueTypeArray {
-		containerLen := d.arrayStart(d.d.ReadArrayStart())
-		if containerLen == 0 {
-			d.arrayEnd()
-			return
-		}
-
-		tisfi := ti.sfi.source()
-		hasLen := containerLen >= 0
-
-		for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
-			d.arrayElem(j == 0)
-			if j < len(tisfi) {
-				d.kStructField(tisfi[j], rv)
-			} else {
-				d.structFieldNotFound(j, "")
-			}
-		}
-
-		d.arrayEnd()
-	} else {
-		halt.onerror(errNeedMapOrArrayDecodeToStruct)
-	}
-}
-
-func (d *decoderMsgpackIO) kSlice(f *decFnInfo, rv reflect.Value) {
-	_ = d.d
-
-	ti := f.ti
-	rvCanset := rv.CanSet()
-
-	ctyp := d.d.ContainerType()
-	if ctyp == valueTypeBytes || ctyp == valueTypeString {
-
-		if !(ti.rtid == uint8SliceTypId || ti.elemkind == uint8(reflect.Uint8)) {
-			halt.errorf("bytes/string in stream must decode into slice/array of bytes, not %v", ti.rt)
-		}
-		rvbs := rvGetBytes(rv)
-		if rvCanset {
-			bs2, bst := d.decodeBytesInto(rvbs, false)
-			if bst != dBytesIntoParamOut {
-				rvSetBytes(rv, bs2)
-			}
-		} else {
-
-			d.decodeBytesInto(rvbs[:len(rvbs):len(rvbs)], true)
-		}
-		return
-	}
-
-	var containerLenS int
-	isArray := ctyp == valueTypeArray
-	if isArray {
-		containerLenS = d.arrayStart(d.d.ReadArrayStart())
-	} else if ctyp == valueTypeMap {
-		containerLenS = d.mapStart(d.d.ReadMapStart()) * 2
-	} else {
-		halt.errorStr2("decoding into a slice, expect map/array - got ", ctyp.String())
-	}
-
-	if containerLenS == 0 {
-		if rvCanset {
-			if rvIsNil(rv) {
-				rvSetDirect(rv, rvSliceZeroCap(ti.rt))
-			} else {
-				rvSetSliceLen(rv, 0)
-			}
-		}
-		if isArray {
-			d.arrayEnd()
-		} else {
-			d.mapEnd()
-		}
-		return
-	}
-
-	rtelem0Mut := !scalarBitset.isset(ti.elemkind)
-	rtelem := ti.elem
-
-	for k := reflect.Kind(ti.elemkind); k == reflect.Ptr; k = rtelem.Kind() {
-		rtelem = rtelem.Elem()
-	}
-
-	var fn *decFnMsgpackIO
-
-	var rvChanged bool
-
-	var rv0 = rv
-	var rv9 reflect.Value
-
-	rvlen := rvLenSlice(rv)
-	rvcap := rvCapSlice(rv)
-	maxInitLen := d.maxInitLen()
-	hasLen := containerLenS >= 0
-	if hasLen {
-		if containerLenS > rvcap {
-			oldRvlenGtZero := rvlen > 0
-			rvlen1 := int(decInferLen(containerLenS, maxInitLen, uint(ti.elemsize)))
-			if rvlen1 == rvlen {
-			} else if rvlen1 <= rvcap {
-				if rvCanset {
-					rvlen = rvlen1
-					rvSetSliceLen(rv, rvlen)
-				}
-			} else if rvCanset {
-				rvlen = rvlen1
-				rv, rvCanset = rvMakeSlice(rv, f.ti, rvlen, rvlen)
-				rvcap = rvlen
-				rvChanged = !rvCanset
-			} else {
-				halt.errorStr("cannot decode into non-settable slice")
-			}
-			if rvChanged && oldRvlenGtZero && rtelem0Mut {
-				rvCopySlice(rv, rv0, rtelem)
-			}
-		} else if containerLenS != rvlen {
-			if rvCanset {
-				rvlen = containerLenS
-				rvSetSliceLen(rv, rvlen)
-			}
-		}
-	}
-
-	var elemReset = d.h.SliceElementReset
-
-	var rtelemIsPtr bool
-	var rtelemElem reflect.Type
-	builtin := ti.tielem.flagDecBuiltin
-	if builtin {
-		rtelemIsPtr = ti.elemkind == uint8(reflect.Ptr)
-		if rtelemIsPtr {
-			rtelemElem = ti.elem.Elem()
-		}
-	}
-
-	var j int
-	for ; d.containerNext(j, containerLenS, hasLen); j++ {
-		if j == 0 {
-			if rvIsNil(rv) {
-				if rvCanset {
-					rvlen = int(decInferLen(containerLenS, maxInitLen, uint(ti.elemsize)))
-					rv, rvCanset = rvMakeSlice(rv, f.ti, rvlen, rvlen)
-					rvcap = rvlen
-					rvChanged = !rvCanset
-				} else {
-					halt.errorStr("cannot decode into non-settable slice")
-				}
-			}
-			if fn == nil {
-				fn = d.fn(rtelem)
-			}
-		}
-
-		if ctyp == valueTypeArray {
-			d.arrayElem(j == 0)
-		} else if j&1 == 0 {
-			d.mapElemKey(j == 0)
-		} else {
-			d.mapElemValue()
-		}
-
-		if j >= rvlen {
-
-			if rvlen < rvcap {
-				rvlen = rvcap
-				if rvCanset {
-					rvSetSliceLen(rv, rvlen)
-				} else if rvChanged {
-					rv = rvSlice(rv, rvlen)
-				} else {
-					halt.onerror(errExpandSliceCannotChange)
-				}
-			} else {
-				if !(rvCanset || rvChanged) {
-					halt.onerror(errExpandSliceCannotChange)
-				}
-				rv, rvcap, rvCanset = rvGrowSlice(rv, f.ti, rvcap, 1)
-
-				rvlen = rvcap
-				rvChanged = !rvCanset
-			}
-		}
-
-		rv9 = rvArrayIndex(rv, j, f.ti, true)
-		if elemReset {
-			rvSetZero(rv9)
-		}
-		if d.d.TryNil() {
-			rvSetZero(rv9)
-		} else if builtin {
-			if rtelemIsPtr {
-				if rvIsNil(rv9) {
-					rvSetDirect(rv9, reflect.New(rtelemElem))
-				}
-				d.decode(rv2i(rv9))
-			} else {
-				d.decode(rv2i(rvAddr(rv9, ti.tielem.ptr)))
-			}
-		} else {
-			d.decodeValueNoCheckNil(rv9, fn)
-		}
-	}
-	if j < rvlen {
-		if rvCanset {
-			rvSetSliceLen(rv, j)
-		} else if rvChanged {
-			rv = rvSlice(rv, j)
-		}
-
-	} else if j == 0 && rvIsNil(rv) {
-		if rvCanset {
-			rv = rvSliceZeroCap(ti.rt)
-			rvCanset = false
-			rvChanged = true
-		}
-	}
-	if isArray {
-		d.arrayEnd()
-	} else {
-		d.mapEnd()
-	}
-
-	if rvChanged {
-		rvSetDirect(rv0, rv)
-	}
-}
-
-func (d *decoderMsgpackIO) kArray(f *decFnInfo, rv reflect.Value) {
-	_ = d.d
-
-	ti := f.ti
-	ctyp := d.d.ContainerType()
-	if handleBytesWithinKArray && (ctyp == valueTypeBytes || ctyp == valueTypeString) {
-
-		if ti.elemkind != uint8(reflect.Uint8) {
-			halt.errorf("bytes/string in stream can decode into array of bytes, but not %v", ti.rt)
-		}
-		rvbs := rvGetArrayBytes(rv, nil)
-		d.decodeBytesInto(rvbs, true)
-		return
-	}
-
-	var containerLenS int
-	isArray := ctyp == valueTypeArray
-	if isArray {
-		containerLenS = d.arrayStart(d.d.ReadArrayStart())
-	} else if ctyp == valueTypeMap {
-		containerLenS = d.mapStart(d.d.ReadMapStart()) * 2
-	} else {
-		halt.errorStr2("decoding into a slice, expect map/array - got ", ctyp.String())
-	}
-
-	if containerLenS == 0 {
-		if isArray {
-			d.arrayEnd()
-		} else {
-			d.mapEnd()
-		}
-		return
-	}
-
-	rtelem := ti.elem
-	for k := reflect.Kind(ti.elemkind); k == reflect.Ptr; k = rtelem.Kind() {
-		rtelem = rtelem.Elem()
-	}
-
-	var rv9 reflect.Value
-
-	rvlen := rv.Len()
-	hasLen := containerLenS >= 0
-	if hasLen && containerLenS > rvlen {
-		halt.errorf("cannot decode into array with length: %v, less than container length: %v", any(rvlen), any(containerLenS))
-	}
-
-	var elemReset = d.h.SliceElementReset
-
-	var rtelemIsPtr bool
-	var rtelemElem reflect.Type
-	var fn *decFnMsgpackIO
-	builtin := ti.tielem.flagDecBuiltin
-	if builtin {
-		rtelemIsPtr = ti.elemkind == uint8(reflect.Ptr)
-		if rtelemIsPtr {
-			rtelemElem = ti.elem.Elem()
-		}
-	} else {
-		fn = d.fn(rtelem)
-	}
-
-	for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
-		if ctyp == valueTypeArray {
-			d.arrayElem(j == 0)
-		} else if j&1 == 0 {
-			d.mapElemKey(j == 0)
-		} else {
-			d.mapElemValue()
-		}
-
-		if j >= rvlen {
-			d.arrayCannotExpand(rvlen, j+1)
-			d.swallow()
-			continue
-		}
-
-		rv9 = rvArrayIndex(rv, j, f.ti, false)
-		if elemReset {
-			rvSetZero(rv9)
-		}
-		if d.d.TryNil() {
-			rvSetZero(rv9)
-		} else if builtin {
-			if rtelemIsPtr {
-				if rvIsNil(rv9) {
-					rvSetDirect(rv9, reflect.New(rtelemElem))
-				}
-				d.decode(rv2i(rv9))
-			} else {
-				d.decode(rv2i(rvAddr(rv9, ti.tielem.ptr)))
-			}
-		} else {
-			d.decodeValueNoCheckNil(rv9, fn)
-		}
-	}
-	if isArray {
-		d.arrayEnd()
-	} else {
-		d.mapEnd()
-	}
-}
-
-func (d *decoderMsgpackIO) kChan(f *decFnInfo, rv reflect.Value) {
-	_ = d.d
-
-	ti := f.ti
-	if ti.chandir&uint8(reflect.SendDir) == 0 {
-		halt.errorStr("receive-only channel cannot be decoded")
-	}
-	ctyp := d.d.ContainerType()
-	if ctyp == valueTypeBytes || ctyp == valueTypeString {
-
-		if !(ti.rtid == uint8SliceTypId || ti.elemkind == uint8(reflect.Uint8)) {
-			halt.errorf("bytes/string in stream must decode into slice/array of bytes, not %v", ti.rt)
-		}
-		bs2, _ := d.d.DecodeBytes()
-		irv := rv2i(rv)
-		ch, ok := irv.(chan<- byte)
-		if !ok {
-			ch = irv.(chan byte)
-		}
-		for _, b := range bs2 {
-			ch <- b
-		}
-		return
-	}
-
-	var rvCanset = rv.CanSet()
-
-	var containerLenS int
-	isArray := ctyp == valueTypeArray
-	if isArray {
-		containerLenS = d.arrayStart(d.d.ReadArrayStart())
-	} else if ctyp == valueTypeMap {
-		containerLenS = d.mapStart(d.d.ReadMapStart()) * 2
-	} else {
-		halt.errorStr2("decoding into a slice, expect map/array - got ", ctyp.String())
-	}
-
-	if containerLenS == 0 {
-		if rvCanset && rvIsNil(rv) {
-			rvSetDirect(rv, reflect.MakeChan(ti.rt, 0))
-		}
-		if isArray {
-			d.arrayEnd()
-		} else {
-			d.mapEnd()
-		}
-		return
-	}
-
-	rtelem := ti.elem
-	useTransient := decUseTransient && ti.elemkind != byte(reflect.Ptr) && ti.tielem.flagCanTransient
-
-	for k := reflect.Kind(ti.elemkind); k == reflect.Ptr; k = rtelem.Kind() {
-		rtelem = rtelem.Elem()
-	}
-
-	var fn *decFnMsgpackIO
-
-	var rvChanged bool
-	var rv0 = rv
-	var rv9 reflect.Value
-
-	var rvlen int
-	hasLen := containerLenS >= 0
-	maxInitLen := d.maxInitLen()
-
-	for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
-		if j == 0 {
-			if rvIsNil(rv) {
-				if hasLen {
-					rvlen = int(decInferLen(containerLenS, maxInitLen, uint(ti.elemsize)))
-				} else {
-					rvlen = decDefChanCap
-				}
-				if rvCanset {
-					rv = reflect.MakeChan(ti.rt, rvlen)
-					rvChanged = true
-				} else {
-					halt.errorStr("cannot decode into non-settable chan")
-				}
-			}
-			if fn == nil {
-				fn = d.fn(rtelem)
-			}
-		}
-
-		if ctyp == valueTypeArray {
-			d.arrayElem(j == 0)
-		} else if j&1 == 0 {
-			d.mapElemKey(j == 0)
-		} else {
-			d.mapElemValue()
-		}
-
-		if rv9.IsValid() {
-			rvSetZero(rv9)
-		} else if useTransient {
-			rv9 = d.perType.TransientAddrK(ti.elem, reflect.Kind(ti.elemkind))
-		} else {
-			rv9 = rvZeroAddrK(ti.elem, reflect.Kind(ti.elemkind))
-		}
-		if !d.d.TryNil() {
-			d.decodeValueNoCheckNil(rv9, fn)
-		}
-		rv.Send(rv9)
-	}
-	if isArray {
-		d.arrayEnd()
-	} else {
-		d.mapEnd()
-	}
-
-	if rvChanged {
-		rvSetDirect(rv0, rv)
-	}
-
-}
-
-func (d *decoderMsgpackIO) kMap(f *decFnInfo, rv reflect.Value) {
-	_ = d.d
-	containerLen := d.mapStart(d.d.ReadMapStart())
-	ti := f.ti
-	if rvIsNil(rv) {
-		rvlen := int(decInferLen(containerLen, d.maxInitLen(), uint(ti.keysize+ti.elemsize)))
-		rvSetDirect(rv, makeMapReflect(ti.rt, rvlen))
-	}
-
-	if containerLen == 0 {
-		d.mapEnd()
-		return
-	}
-
-	ktype, vtype := ti.key, ti.elem
-	ktypeId := rt2id(ktype)
-	vtypeKind := reflect.Kind(ti.elemkind)
-	ktypeKind := reflect.Kind(ti.keykind)
-	mparams := getMapReqParams(ti)
-
-	vtypePtr := vtypeKind == reflect.Ptr
-	ktypePtr := ktypeKind == reflect.Ptr
-
-	vTransient := decUseTransient && !vtypePtr && ti.tielem.flagCanTransient
-
-	kTransient := vTransient && !ktypePtr && ti.tikey.flagCanTransient
-
-	var vtypeElem reflect.Type
-
-	var keyFn, valFn *decFnMsgpackIO
-	var ktypeLo, vtypeLo = ktype, vtype
-
-	if ktypeKind == reflect.Ptr {
-		for ktypeLo = ktype.Elem(); ktypeLo.Kind() == reflect.Ptr; ktypeLo = ktypeLo.Elem() {
-		}
-	}
-
-	if vtypePtr {
-		vtypeElem = vtype.Elem()
-		for vtypeLo = vtypeElem; vtypeLo.Kind() == reflect.Ptr; vtypeLo = vtypeLo.Elem() {
-		}
-	}
-
-	rvkMut := !scalarBitset.isset(ti.keykind)
-	rvvMut := !scalarBitset.isset(ti.elemkind)
-	rvvCanNil := isnilBitset.isset(ti.elemkind)
-
-	var rvk, rvkn, rvv, rvvn, rvva, rvvz reflect.Value
-
-	var doMapGet, doMapSet bool
-
-	if !d.h.MapValueReset {
-		if rvvMut && (vtypeKind != reflect.Interface || !d.h.InterfaceReset) {
-			doMapGet = true
-			rvva = mapAddrLoopvarRV(vtype, vtypeKind)
-		}
-	}
-
-	ktypeIsString := ktypeId == stringTypId
-	ktypeIsIntf := ktypeId == intfTypId
-	hasLen := containerLen >= 0
-
-	var kstr2bs []byte
-	var kstr string
-
-	var mapKeyStringSharesBytesBuf bool
-	var att dBytesAttachState
-
-	var vElem, kElem reflect.Type
-	kbuiltin := ti.tikey.flagDecBuiltin && ti.keykind != uint8(reflect.Slice)
-	vbuiltin := ti.tielem.flagDecBuiltin
-	if kbuiltin && ktypePtr {
-		kElem = ti.key.Elem()
-	}
-	if vbuiltin && vtypePtr {
-		vElem = ti.elem.Elem()
-	}
-
-	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
-		mapKeyStringSharesBytesBuf = false
-		kstr = ""
-		if j == 0 {
-
-			if kTransient {
-				rvk = d.perType.TransientAddr2K(ktype, ktypeKind)
-			} else {
-				rvk = rvZeroAddrK(ktype, ktypeKind)
-			}
-			if !rvkMut {
-				rvkn = rvk
-			}
-			if !rvvMut {
-				if vTransient {
-					rvvn = d.perType.TransientAddrK(vtype, vtypeKind)
-				} else {
-					rvvn = rvZeroAddrK(vtype, vtypeKind)
-				}
-			}
-			if !ktypeIsString && keyFn == nil {
-				keyFn = d.fn(ktypeLo)
-			}
-			if valFn == nil {
-				valFn = d.fn(vtypeLo)
-			}
-		} else if rvkMut {
-			rvSetZero(rvk)
-		} else {
-			rvk = rvkn
-		}
-
-		d.mapElemKey(j == 0)
-
-		if d.d.TryNil() {
-			rvSetZero(rvk)
-		} else if ktypeIsString {
-			kstr2bs, att = d.d.DecodeStringAsBytes()
-			kstr, mapKeyStringSharesBytesBuf = d.bytes2Str(kstr2bs, att)
-			rvSetString(rvk, kstr)
-		} else {
-			if kbuiltin {
-				if ktypePtr {
-					if rvIsNil(rvk) {
-						rvSetDirect(rvk, reflect.New(kElem))
-					}
-					d.decode(rv2i(rvk))
-				} else {
-					d.decode(rv2i(rvAddr(rvk, ti.tikey.ptr)))
-				}
-			} else {
-				d.decodeValueNoCheckNil(rvk, keyFn)
-			}
-
-			if ktypeIsIntf {
-				if rvk2 := rvk.Elem(); rvk2.IsValid() && rvk2.Type() == uint8SliceTyp {
-					kstr2bs = rvGetBytes(rvk2)
-					kstr, mapKeyStringSharesBytesBuf = d.bytes2Str(kstr2bs, dBytesAttachView)
-					rvSetIntf(rvk, rv4istr(kstr))
-				}
-
-			}
-		}
-
-		if mapKeyStringSharesBytesBuf && d.bufio {
-			if ktypeIsString {
-				rvSetString(rvk, d.detach2Str(kstr2bs, att))
-			} else {
-				rvSetIntf(rvk, rv4istr(d.detach2Str(kstr2bs, att)))
-			}
-			mapKeyStringSharesBytesBuf = false
-		}
-
-		d.mapElemValue()
-
-		if d.d.TryNil() {
-			if mapKeyStringSharesBytesBuf {
-				if ktypeIsString {
-					rvSetString(rvk, d.detach2Str(kstr2bs, att))
-				} else {
-					rvSetIntf(rvk, rv4istr(d.detach2Str(kstr2bs, att)))
-				}
-			}
-
-			if !rvvz.IsValid() {
-				rvvz = rvZeroK(vtype, vtypeKind)
-			}
-			mapSet(rv, rvk, rvvz, mparams)
-			continue
-		}
-
-		doMapSet = true
-
-		if !rvvMut {
-			rvv = rvvn
-		} else if !doMapGet {
-			goto NEW_RVV
-		} else {
-			rvv = mapGet(rv, rvk, rvva, mparams)
-			if !rvv.IsValid() || (rvvCanNil && rvIsNil(rvv)) {
-				goto NEW_RVV
-			}
-			switch vtypeKind {
-			case reflect.Ptr, reflect.Map:
-				doMapSet = false
-			case reflect.Interface:
-
-				rvvn = rvv.Elem()
-				if k := rvvn.Kind(); (k == reflect.Ptr || k == reflect.Map) && !rvIsNil(rvvn) {
-					d.decodeValueNoCheckNil(rvvn, nil)
-					continue
-				}
-
-				rvvn = rvZeroAddrK(vtype, vtypeKind)
-				rvSetIntf(rvvn, rvv)
-				rvv = rvvn
-			default:
-
-				if vTransient {
-					rvvn = d.perType.TransientAddrK(vtype, vtypeKind)
-				} else {
-					rvvn = rvZeroAddrK(vtype, vtypeKind)
-				}
-				rvSetDirect(rvvn, rvv)
-				rvv = rvvn
-			}
-		}
-		goto DECODE_VALUE_NO_CHECK_NIL
-
-	NEW_RVV:
-		if vtypePtr {
-			rvv = reflect.New(vtypeElem)
-		} else if vTransient {
-			rvv = d.perType.TransientAddrK(vtype, vtypeKind)
-		} else {
-			rvv = rvZeroAddrK(vtype, vtypeKind)
-		}
-
-	DECODE_VALUE_NO_CHECK_NIL:
-		if doMapSet && mapKeyStringSharesBytesBuf {
-			if ktypeIsString {
-				rvSetString(rvk, d.detach2Str(kstr2bs, att))
-			} else {
-				rvSetIntf(rvk, rv4istr(d.detach2Str(kstr2bs, att)))
-			}
-		}
-		if vbuiltin {
-			if vtypePtr {
-				if rvIsNil(rvv) {
-					rvSetDirect(rvv, reflect.New(vElem))
-				}
-				d.decode(rv2i(rvv))
-			} else {
-				d.decode(rv2i(rvAddr(rvv, ti.tielem.ptr)))
-			}
-		} else {
-			d.decodeValueNoCheckNil(rvv, valFn)
-		}
-		if doMapSet {
-			mapSet(rv, rvk, rvv, mparams)
-		}
-	}
-
-	d.mapEnd()
-}
-
-func (d *decoderMsgpackIO) init(h Handle) {
-	initHandle(h)
-	callMake(&d.d)
-	d.hh = h
-	d.h = h.getBasicHandle()
-
-	d.err = errDecoderNotInitialized
-
-	if d.h.InternString && d.is == nil {
-		d.is.init()
-	}
-
-	d.fp = d.d.init(h, &d.decoderBase, d).(*fastpathDsMsgpackIO)
-
-	if d.bytes {
-		d.rtidFn = &d.h.rtidFnsDecBytes
-		d.rtidFnNoExt = &d.h.rtidFnsDecNoExtBytes
-	} else {
-		d.bufio = d.h.ReaderBufferSize > 0
-		d.rtidFn = &d.h.rtidFnsDecIO
-		d.rtidFnNoExt = &d.h.rtidFnsDecNoExtIO
-	}
-
-	d.reset()
-
-}
-
-func (d *decoderMsgpackIO) reset() {
-	d.d.reset()
-	d.err = nil
-	d.c = 0
-	d.depth = 0
-	d.calls = 0
-
-	d.maxdepth = decDefMaxDepth
-	if d.h.MaxDepth > 0 {
-		d.maxdepth = d.h.MaxDepth
-	}
-	d.mtid = 0
-	d.stid = 0
-	d.mtr = false
-	d.str = false
-	if d.h.MapType != nil {
-		d.mtid = rt2id(d.h.MapType)
-		_, d.mtr = fastpathAvIndex(d.mtid)
-	}
-	if d.h.SliceType != nil {
-		d.stid = rt2id(d.h.SliceType)
-		_, d.str = fastpathAvIndex(d.stid)
-	}
-}
-
-func (d *decoderMsgpackIO) Reset(r io.Reader) {
-	if d.bytes {
-		halt.onerror(errDecNoResetBytesWithReader)
-	}
-	d.reset()
-	if r == nil {
-		r = &eofReader
-	}
-	d.d.resetInIO(r)
-}
-
-func (d *decoderMsgpackIO) ResetBytes(in []byte) {
-	if !d.bytes {
-		halt.onerror(errDecNoResetReaderWithBytes)
-	}
-	d.resetBytes(in)
-}
-
-func (d *decoderMsgpackIO) resetBytes(in []byte) {
-	d.reset()
-	if in == nil {
-		in = zeroByteSlice
-	}
-	d.d.resetInBytes(in)
-}
-
-func (d *decoderMsgpackIO) ResetString(s string) {
-	d.ResetBytes(bytesView(s))
-}
-
-func (d *decoderMsgpackIO) Decode(v interface{}) (err error) {
-
-	defer panicValToErr(d, callRecoverSentinel, &d.err, &err, debugging)
-	d.mustDecode(v)
-	return
-}
-
-func (d *decoderMsgpackIO) MustDecode(v interface{}) {
-	defer panicValToErr(d, callRecoverSentinel, &d.err, nil, true)
-	d.mustDecode(v)
-	return
-}
-
-func (d *decoderMsgpackIO) mustDecode(v interface{}) {
-	halt.onerror(d.err)
-	if d.hh == nil {
-		halt.onerror(errNoFormatHandle)
-	}
-
-	d.calls++
-	d.decode(v)
-	d.calls--
-}
-
-func (d *decoderMsgpackIO) Release() {}
-
-func (d *decoderMsgpackIO) swallow() {
-	d.d.nextValueBytes()
-}
-
-func (d *decoderMsgpackIO) nextValueBytes() []byte {
-	return d.d.nextValueBytes()
-}
-
-func (d *decoderMsgpackIO) decode(iv interface{}) {
-	_ = d.d
-
-	rv, ok := isNil(iv, true)
-	if ok {
-		halt.onerror(errCannotDecodeIntoNil)
-	}
-
-	switch v := iv.(type) {
-
-	case *string:
-		*v = d.detach2Str(d.d.DecodeStringAsBytes())
-	case *bool:
-		*v = d.d.DecodeBool()
-	case *int:
-		*v = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
-	case *int8:
-		*v = int8(chkOvf.IntV(d.d.DecodeInt64(), 8))
-	case *int16:
-		*v = int16(chkOvf.IntV(d.d.DecodeInt64(), 16))
-	case *int32:
-		*v = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
-	case *int64:
-		*v = d.d.DecodeInt64()
-	case *uint:
-		*v = uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))
-	case *uint8:
-		*v = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
-	case *uint16:
-		*v = uint16(chkOvf.UintV(d.d.DecodeUint64(), 16))
-	case *uint32:
-		*v = uint32(chkOvf.UintV(d.d.DecodeUint64(), 32))
-	case *uint64:
-		*v = d.d.DecodeUint64()
-	case *uintptr:
-		*v = uintptr(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))
-	case *float32:
-		*v = d.d.DecodeFloat32()
-	case *float64:
-		*v = d.d.DecodeFloat64()
-	case *complex64:
-		*v = complex(d.d.DecodeFloat32(), 0)
-	case *complex128:
-		*v = complex(d.d.DecodeFloat64(), 0)
-	case *[]byte:
-		*v, _ = d.decodeBytesInto(*v, false)
-	case []byte:
-
-		d.decodeBytesInto(v[:len(v):len(v)], true)
-	case *time.Time:
-		*v = d.d.DecodeTime()
-	case *Raw:
-		*v = d.rawBytes()
-
-	case *interface{}:
-		d.decodeValue(rv4iptr(v), nil)
-
-	case reflect.Value:
-		if ok, _ = isDecodeable(v); !ok {
-			d.haltAsNotDecodeable(v)
-		}
-		d.decodeValue(v, nil)
-
-	default:
-
-		if skipFastpathTypeSwitchInDirectCall || !d.dh.fastpathDecodeTypeSwitch(iv, d) {
-			if !rv.IsValid() {
-				rv = reflect.ValueOf(iv)
-			}
-			if ok, _ = isDecodeable(rv); !ok {
-				d.haltAsNotDecodeable(rv)
-			}
-			d.decodeValue(rv, nil)
-		}
-	}
-}
-
-func (d *decoderMsgpackIO) decodeValue(rv reflect.Value, fn *decFnMsgpackIO) {
-	if d.d.TryNil() {
-		decSetNonNilRV2Zero(rv)
-	} else {
-		d.decodeValueNoCheckNil(rv, fn)
-	}
-}
-
-func (d *decoderMsgpackIO) decodeValueNoCheckNil(rv reflect.Value, fn *decFnMsgpackIO) {
-
-	var rvp reflect.Value
-	var rvpValid bool
-PTR:
-	if rv.Kind() == reflect.Ptr {
-		rvpValid = true
-		if rvIsNil(rv) {
-			rvSetDirect(rv, reflect.New(rv.Type().Elem()))
-		}
-		rvp = rv
-		rv = rv.Elem()
-		goto PTR
-	}
-
-	if fn == nil {
-		fn = d.fn(rv.Type())
-	}
-	if fn.i.addrD {
-		if rvpValid {
-			rv = rvp
-		} else if rv.CanAddr() {
-			rv = rvAddr(rv, fn.i.ti.ptr)
-		} else if fn.i.addrDf {
-			halt.errorStr("cannot decode into a non-pointer value")
-		}
-	}
-	fn.fd(d, &fn.i, rv)
-}
-
-func (d *decoderMsgpackIO) decodeAs(v interface{}, t reflect.Type, ext bool) {
-	if ext {
-		d.decodeValue(baseRV(v), d.fn(t))
-	} else {
-		d.decodeValue(baseRV(v), d.fnNoExt(t))
-	}
-}
-
-func (d *decoderMsgpackIO) structFieldNotFound(index int, rvkencname string) {
-
-	if d.h.ErrorIfNoField {
-		if index >= 0 {
-			halt.errorInt("no matching struct field found when decoding stream array at index ", int64(index))
-		} else if rvkencname != "" {
-			halt.errorStr2("no matching struct field found when decoding stream map with key ", rvkencname)
-		}
-	}
-	d.swallow()
-}
-
-func (d *decoderMsgpackIO) decodeBytesInto(out []byte, mustFit bool) (v []byte, state dBytesIntoState) {
-	v, att := d.d.DecodeBytes()
-	if cap(v) == 0 || (att >= dBytesAttachViewZerocopy && !mustFit) {
-
-		return
-	}
-	if len(v) == 0 {
-		v = zeroByteSlice
-		return
-	}
-	if len(out) == len(v) {
-		state = dBytesIntoParamOut
-	} else if cap(out) >= len(v) {
-		out = out[:len(v)]
-		state = dBytesIntoParamOutSlice
-	} else if mustFit {
-		halt.errorf("bytes capacity insufficient for decoded bytes: got/expected: %d/%d", len(v), len(out))
-	} else {
-		out = make([]byte, len(v))
-		state = dBytesIntoNew
-	}
-	copy(out, v)
-	v = out
-	return
-}
-
-func (d *decoderMsgpackIO) rawBytes() (v []byte) {
-
-	v = d.d.nextValueBytes()
-	if d.bytes && !d.h.ZeroCopy {
-		vv := make([]byte, len(v))
-		copy(vv, v)
-		v = vv
-	}
-	return
-}
-
-func (d *decoderMsgpackIO) wrapErr(v error, err *error) {
-	*err = wrapCodecErr(v, d.hh.Name(), d.d.NumBytesRead(), false)
-}
-
-func (d *decoderMsgpackIO) NumBytesRead() int {
-	return d.d.NumBytesRead()
-}
-
-func (d *decoderMsgpackIO) containerNext(j, containerLen int, hasLen bool) bool {
-
-	if hasLen {
-		return j < containerLen
-	}
-	return !d.d.CheckBreak()
-}
-
-func (d *decoderMsgpackIO) mapElemKey(firstTime bool) {
-	d.d.ReadMapElemKey(firstTime)
-	d.c = containerMapKey
-}
-
-func (d *decoderMsgpackIO) mapElemValue() {
-	d.d.ReadMapElemValue()
-	d.c = containerMapValue
-}
-
-func (d *decoderMsgpackIO) mapEnd() {
-	d.d.ReadMapEnd()
-	d.depthDecr()
-	d.c = 0
-}
-
-func (d *decoderMsgpackIO) arrayElem(firstTime bool) {
-	d.d.ReadArrayElem(firstTime)
-	d.c = containerArrayElem
-}
-
-func (d *decoderMsgpackIO) arrayEnd() {
-	d.d.ReadArrayEnd()
-	d.depthDecr()
-	d.c = 0
-}
-
-func (d *decoderMsgpackIO) interfaceExtConvertAndDecode(v interface{}, ext InterfaceExt) {
-
-	var vv interface{}
-	d.decode(&vv)
-	ext.UpdateExt(v, vv)
-
-}
-
-func (d *decoderMsgpackIO) fn(t reflect.Type) *decFnMsgpackIO {
-	return d.dh.decFnViaBH(t, d.rtidFn, d.h, d.fp, false)
-}
-
-func (d *decoderMsgpackIO) fnNoExt(t reflect.Type) *decFnMsgpackIO {
-	return d.dh.decFnViaBH(t, d.rtidFnNoExt, d.h, d.fp, true)
-}
-
-func (helperDecDriverMsgpackIO) newDecoderBytes(in []byte, h Handle) *decoderMsgpackIO {
-	var c1 decoderMsgpackIO
-	c1.bytes = true
-	c1.init(h)
-	c1.ResetBytes(in)
-	return &c1
-}
-
-func (helperDecDriverMsgpackIO) newDecoderIO(in io.Reader, h Handle) *decoderMsgpackIO {
-	var c1 decoderMsgpackIO
-	c1.init(h)
-	c1.Reset(in)
-	return &c1
-}
-
-func (helperDecDriverMsgpackIO) decFnloadFastpathUnderlying(ti *typeInfo, fp *fastpathDsMsgpackIO) (f *fastpathDMsgpackIO, u reflect.Type) {
-	rtid := rt2id(ti.fastpathUnderlying)
-	idx, ok := fastpathAvIndex(rtid)
-	if !ok {
-		return
-	}
-	f = &fp[idx]
-	if uint8(reflect.Array) == ti.kind {
-		u = reflect.ArrayOf(ti.rt.Len(), ti.elem)
-	} else {
-		u = f.rt
-	}
-	return
-}
-
-func (helperDecDriverMsgpackIO) decFindRtidFn(s []decRtidFnMsgpackIO, rtid uintptr) (i uint, fn *decFnMsgpackIO) {
-
-	var h uint
-	var j = uint(len(s))
-LOOP:
-	if i < j {
-		h = (i + j) >> 1
-		if s[h].rtid < rtid {
-			i = h + 1
-		} else {
-			j = h
-		}
-		goto LOOP
-	}
-	if i < uint(len(s)) && s[i].rtid == rtid {
-		fn = s[i].fn
-	}
-	return
-}
-
-func (helperDecDriverMsgpackIO) decFromRtidFnSlice(fns *atomicRtidFnSlice) (s []decRtidFnMsgpackIO) {
-	if v := fns.load(); v != nil {
-		s = *(lowLevelToPtr[[]decRtidFnMsgpackIO](v))
-	}
-	return
-}
-
-func (dh helperDecDriverMsgpackIO) decFnViaBH(rt reflect.Type, fns *atomicRtidFnSlice, x *BasicHandle, fp *fastpathDsMsgpackIO,
-	checkExt bool) (fn *decFnMsgpackIO) {
-	return dh.decFnVia(rt, fns, x.typeInfos(), &x.mu, x.extHandle, fp,
-		checkExt, x.CheckCircularRef, x.timeBuiltin, x.binaryHandle, x.jsonHandle)
-}
-
-func (dh helperDecDriverMsgpackIO) decFnVia(rt reflect.Type, fns *atomicRtidFnSlice,
-	tinfos *TypeInfos, mu *sync.Mutex, exth extHandle, fp *fastpathDsMsgpackIO,
-	checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *decFnMsgpackIO) {
-	rtid := rt2id(rt)
-	var sp []decRtidFnMsgpackIO = dh.decFromRtidFnSlice(fns)
-	if sp != nil {
-		_, fn = dh.decFindRtidFn(sp, rtid)
-	}
-	if fn == nil {
-		fn = dh.decFnViaLoader(rt, rtid, fns, tinfos, mu, exth, fp, checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json)
-	}
-	return
-}
-
-func (dh helperDecDriverMsgpackIO) decFnViaLoader(rt reflect.Type, rtid uintptr, fns *atomicRtidFnSlice,
-	tinfos *TypeInfos, mu *sync.Mutex, exth extHandle, fp *fastpathDsMsgpackIO,
-	checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *decFnMsgpackIO) {
-
-	fn = dh.decFnLoad(rt, rtid, tinfos, exth, fp, checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json)
-	var sp []decRtidFnMsgpackIO
-	mu.Lock()
-	sp = dh.decFromRtidFnSlice(fns)
-
-	if sp == nil {
-		sp = []decRtidFnMsgpackIO{{rtid, fn}}
-		fns.store(ptrToLowLevel(&sp))
-	} else {
-		idx, fn2 := dh.decFindRtidFn(sp, rtid)
-		if fn2 == nil {
-			sp2 := make([]decRtidFnMsgpackIO, len(sp)+1)
-			copy(sp2[idx+1:], sp[idx:])
-			copy(sp2, sp[:idx])
-			sp2[idx] = decRtidFnMsgpackIO{rtid, fn}
-			fns.store(ptrToLowLevel(&sp2))
-		}
-	}
-	mu.Unlock()
-	return
-}
-
-func (dh helperDecDriverMsgpackIO) decFnLoad(rt reflect.Type, rtid uintptr, tinfos *TypeInfos,
-	exth extHandle, fp *fastpathDsMsgpackIO,
-	checkExt, checkCircularRef, timeBuiltin, binaryEncoding, json bool) (fn *decFnMsgpackIO) {
-	fn = new(decFnMsgpackIO)
-	fi := &(fn.i)
-	ti := tinfos.get(rtid, rt)
-	fi.ti = ti
-	rk := reflect.Kind(ti.kind)
-
-	fi.addrDf = true
-
-	if rtid == timeTypId && timeBuiltin {
-		fn.fd = (*decoderMsgpackIO).kTime
-	} else if rtid == rawTypId {
-		fn.fd = (*decoderMsgpackIO).raw
-	} else if rtid == rawExtTypId {
-		fn.fd = (*decoderMsgpackIO).rawExt
-		fi.addrD = true
-	} else if xfFn := exth.getExt(rtid, checkExt); xfFn != nil {
-		fi.xfTag, fi.xfFn = xfFn.tag, xfFn.ext
-		fn.fd = (*decoderMsgpackIO).ext
-		fi.addrD = true
-	} else if ti.flagSelfer || ti.flagSelferPtr {
-		fn.fd = (*decoderMsgpackIO).selferUnmarshal
-		fi.addrD = ti.flagSelferPtr
-	} else if supportMarshalInterfaces && binaryEncoding &&
-		(ti.flagBinaryMarshaler || ti.flagBinaryMarshalerPtr) &&
-		(ti.flagBinaryUnmarshaler || ti.flagBinaryUnmarshalerPtr) {
-		fn.fd = (*decoderMsgpackIO).binaryUnmarshal
-		fi.addrD = ti.flagBinaryUnmarshalerPtr
-	} else if supportMarshalInterfaces && !binaryEncoding && json &&
-		(ti.flagJsonMarshaler || ti.flagJsonMarshalerPtr) &&
-		(ti.flagJsonUnmarshaler || ti.flagJsonUnmarshalerPtr) {
-
-		fn.fd = (*decoderMsgpackIO).jsonUnmarshal
-		fi.addrD = ti.flagJsonUnmarshalerPtr
-	} else if supportMarshalInterfaces && !binaryEncoding &&
-		(ti.flagTextMarshaler || ti.flagTextMarshalerPtr) &&
-		(ti.flagTextUnmarshaler || ti.flagTextUnmarshalerPtr) {
-		fn.fd = (*decoderMsgpackIO).textUnmarshal
-		fi.addrD = ti.flagTextUnmarshalerPtr
-	} else {
-		if fastpathEnabled && (rk == reflect.Map || rk == reflect.Slice || rk == reflect.Array) {
-			var rtid2 uintptr
-			if !ti.flagHasPkgPath {
-				rtid2 = rtid
-				if rk == reflect.Array {
-					rtid2 = rt2id(ti.key)
-				}
-				if idx, ok := fastpathAvIndex(rtid2); ok {
-					fn.fd = fp[idx].decfn
-					fi.addrD = true
-					fi.addrDf = false
-					if rk == reflect.Array {
-						fi.addrD = false
-					}
-				}
-			} else {
-
-				xfe, xrt := dh.decFnloadFastpathUnderlying(ti, fp)
-				if xfe != nil {
-					xfnf2 := xfe.decfn
-					if rk == reflect.Array {
-						fi.addrD = false
-						fn.fd = func(d *decoderMsgpackIO, xf *decFnInfo, xrv reflect.Value) {
-							xfnf2(d, xf, rvConvert(xrv, xrt))
-						}
-					} else {
-						fi.addrD = true
-						fi.addrDf = false
-						xptr2rt := reflect.PointerTo(xrt)
-						fn.fd = func(d *decoderMsgpackIO, xf *decFnInfo, xrv reflect.Value) {
-							if xrv.Kind() == reflect.Ptr {
-								xfnf2(d, xf, rvConvert(xrv, xptr2rt))
-							} else {
-								xfnf2(d, xf, rvConvert(xrv, xrt))
-							}
-						}
-					}
-				}
-			}
-		}
-		if fn.fd == nil {
-			switch rk {
-			case reflect.Bool:
-				fn.fd = (*decoderMsgpackIO).kBool
-			case reflect.String:
-				fn.fd = (*decoderMsgpackIO).kString
-			case reflect.Int:
-				fn.fd = (*decoderMsgpackIO).kInt
-			case reflect.Int8:
-				fn.fd = (*decoderMsgpackIO).kInt8
-			case reflect.Int16:
-				fn.fd = (*decoderMsgpackIO).kInt16
-			case reflect.Int32:
-				fn.fd = (*decoderMsgpackIO).kInt32
-			case reflect.Int64:
-				fn.fd = (*decoderMsgpackIO).kInt64
-			case reflect.Uint:
-				fn.fd = (*decoderMsgpackIO).kUint
-			case reflect.Uint8:
-				fn.fd = (*decoderMsgpackIO).kUint8
-			case reflect.Uint16:
-				fn.fd = (*decoderMsgpackIO).kUint16
-			case reflect.Uint32:
-				fn.fd = (*decoderMsgpackIO).kUint32
-			case reflect.Uint64:
-				fn.fd = (*decoderMsgpackIO).kUint64
-			case reflect.Uintptr:
-				fn.fd = (*decoderMsgpackIO).kUintptr
-			case reflect.Float32:
-				fn.fd = (*decoderMsgpackIO).kFloat32
-			case reflect.Float64:
-				fn.fd = (*decoderMsgpackIO).kFloat64
-			case reflect.Complex64:
-				fn.fd = (*decoderMsgpackIO).kComplex64
-			case reflect.Complex128:
-				fn.fd = (*decoderMsgpackIO).kComplex128
-			case reflect.Chan:
-				fn.fd = (*decoderMsgpackIO).kChan
-			case reflect.Slice:
-				fn.fd = (*decoderMsgpackIO).kSlice
-			case reflect.Array:
-				fi.addrD = false
-				fn.fd = (*decoderMsgpackIO).kArray
-			case reflect.Struct:
-				if ti.simple {
-					fn.fd = (*decoderMsgpackIO).kStructSimple
-				} else {
-					fn.fd = (*decoderMsgpackIO).kStruct
-				}
-			case reflect.Map:
-				fn.fd = (*decoderMsgpackIO).kMap
-			case reflect.Interface:
-
-				fn.fd = (*decoderMsgpackIO).kInterface
-			default:
-
-				fn.fd = (*decoderMsgpackIO).kErr
-			}
-		}
-	}
-	return
-}
-func (e *msgpackEncDriverIO) EncodeNil() {
-	e.w.writen1(mpNil)
-}
-
-func (e *msgpackEncDriverIO) EncodeInt(i int64) {
-	if e.h.PositiveIntUnsigned && i >= 0 {
-		e.EncodeUint(uint64(i))
-	} else if i > math.MaxInt8 {
-		if i <= math.MaxInt16 {
-			e.w.writen1(mpInt16)
-			e.w.writen2(bigen.PutUint16(uint16(i)))
-		} else if i <= math.MaxInt32 {
-			e.w.writen1(mpInt32)
-			e.w.writen4(bigen.PutUint32(uint32(i)))
-		} else {
-			e.w.writen1(mpInt64)
-			e.w.writen8(bigen.PutUint64(uint64(i)))
-		}
-	} else if i >= -32 {
-		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 {
-		e.w.writen1(mpInt16)
-		e.w.writen2(bigen.PutUint16(uint16(i)))
-	} else if i >= math.MinInt32 {
-		e.w.writen1(mpInt32)
-		e.w.writen4(bigen.PutUint32(uint32(i)))
-	} else {
-		e.w.writen1(mpInt64)
-		e.w.writen8(bigen.PutUint64(uint64(i)))
-	}
-}
-
-func (e *msgpackEncDriverIO) EncodeUint(i uint64) {
-	if i <= math.MaxInt8 {
-		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 {
-		e.w.writen1(mpUint16)
-		e.w.writen2(bigen.PutUint16(uint16(i)))
-	} else if i <= math.MaxUint32 {
-		e.w.writen1(mpUint32)
-		e.w.writen4(bigen.PutUint32(uint32(i)))
-	} else {
-		e.w.writen1(mpUint64)
-		e.w.writen8(bigen.PutUint64(uint64(i)))
-	}
-}
-
-func (e *msgpackEncDriverIO) EncodeBool(b bool) {
-	if b {
-		e.w.writen1(mpTrue)
-	} else {
-		e.w.writen1(mpFalse)
-	}
-}
-
-func (e *msgpackEncDriverIO) EncodeFloat32(f float32) {
-	e.w.writen1(mpFloat)
-	e.w.writen4(bigen.PutUint32(math.Float32bits(f)))
-}
-
-func (e *msgpackEncDriverIO) EncodeFloat64(f float64) {
-	e.w.writen1(mpDouble)
-	e.w.writen8(bigen.PutUint64(math.Float64bits(f)))
-}
-
-func (e *msgpackEncDriverIO) 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(msgpackContainerRawLegacy, l)
-	}
-	switch l {
-	case 4:
-		e.w.writen4(bigen.PutUint32(uint32(data64)))
-	case 8:
-		e.w.writen8(bigen.PutUint64(data64))
-	case 12:
-		e.w.writen4(bigen.PutUint32(uint32(nsec)))
-		e.w.writen8(bigen.PutUint64(uint64(sec)))
-	}
-}
-
-func (e *msgpackEncDriverIO) EncodeExt(v interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
-	var bs0, bs []byte
-	if ext == SelfExt {
-		bs0 = e.e.blist.get(1024)
-		bs = bs0
-		sideEncode(e.h, &e.h.sideEncPool, func(se encoderI) { oneOffEncode(se, v, &bs, basetype, true) })
-	} else {
-		bs = ext.WriteExt(v)
-	}
-	if bs == nil {
-		e.writeNilBytes()
-		goto END
-	}
-	if e.h.WriteExt {
-		e.encodeExtPreamble(uint8(xtag), len(bs))
-		e.w.writeb(bs)
-	} else {
-		e.EncodeBytes(bs)
-	}
-END:
-	if ext == SelfExt {
-		e.e.blist.put(bs)
-		if !byteSliceSameData(bs0, bs) {
-			e.e.blist.put(bs0)
-		}
-	}
-}
-
-func (e *msgpackEncDriverIO) EncodeRawExt(re *RawExt) {
-	e.encodeExtPreamble(uint8(re.Tag), len(re.Data))
-	e.w.writeb(re.Data)
-}
-
-func (e *msgpackEncDriverIO) encodeExtPreamble(xtag byte, l int) {
-	if l == 1 {
-		e.w.writen2(mpFixExt1, xtag)
-	} else if l == 2 {
-		e.w.writen2(mpFixExt2, xtag)
-	} else if l == 4 {
-		e.w.writen2(mpFixExt4, xtag)
-	} else if l == 8 {
-		e.w.writen2(mpFixExt8, xtag)
-	} else if l == 16 {
-		e.w.writen2(mpFixExt16, xtag)
-	} else if l < 256 {
-		e.w.writen2(mpExt8, byte(l))
-		e.w.writen1(xtag)
-	} else if l < 65536 {
-		e.w.writen1(mpExt16)
-		e.w.writen2(bigen.PutUint16(uint16(l)))
-		e.w.writen1(xtag)
-	} else {
-		e.w.writen1(mpExt32)
-		e.w.writen4(bigen.PutUint32(uint32(l)))
-		e.w.writen1(xtag)
-	}
-}
-
-func (e *msgpackEncDriverIO) WriteArrayStart(length int) {
-	e.writeContainerLen(msgpackContainerList, length)
-}
-
-func (e *msgpackEncDriverIO) WriteMapStart(length int) {
-	e.writeContainerLen(msgpackContainerMap, length)
-}
-
-func (e *msgpackEncDriverIO) WriteArrayEmpty() {
-
-	e.w.writen1(mpFixArrayMin)
-}
-
-func (e *msgpackEncDriverIO) WriteMapEmpty() {
-
-	e.w.writen1(mpFixMapMin)
-}
-
-func (e *msgpackEncDriverIO) EncodeString(s string) {
-	var ct msgpackContainerType
-	if e.h.WriteExt {
-		if e.h.StringToRaw {
-			ct = msgpackContainerBin
-		} else {
-			ct = msgpackContainerStr
-		}
-	} else {
-		ct = msgpackContainerRawLegacy
-	}
-	e.writeContainerLen(ct, len(s))
-	if len(s) > 0 {
-		e.w.writestr(s)
-	}
-}
-
-func (e *msgpackEncDriverIO) EncodeStringNoEscape4Json(v string) { e.EncodeString(v) }
-
-func (e *msgpackEncDriverIO) EncodeStringBytesRaw(bs []byte) {
-	if e.h.WriteExt {
-		e.writeContainerLen(msgpackContainerBin, len(bs))
-	} else {
-		e.writeContainerLen(msgpackContainerRawLegacy, len(bs))
-	}
-	if len(bs) > 0 {
-		e.w.writeb(bs)
-	}
-}
-
-func (e *msgpackEncDriverIO) EncodeBytes(v []byte) {
-	if v == nil {
-		e.writeNilBytes()
-		return
-	}
-	e.EncodeStringBytesRaw(v)
-}
-
-func (e *msgpackEncDriverIO) writeNilOr(v byte) {
-	if !e.h.NilCollectionToZeroLength {
-		v = mpNil
-	}
-	e.w.writen1(v)
-}
-
-func (e *msgpackEncDriverIO) writeNilArray() {
-	e.writeNilOr(mpFixArrayMin)
-}
-
-func (e *msgpackEncDriverIO) writeNilMap() {
-	e.writeNilOr(mpFixMapMin)
-}
-
-func (e *msgpackEncDriverIO) writeNilBytes() {
-	e.writeNilOr(mpFixStrMin)
-}
-
-func (e *msgpackEncDriverIO) writeContainerLen(ct msgpackContainerType, l int) {
-	if ct.fixCutoff > 0 && l < int(ct.fixCutoff) {
-		e.w.writen1(ct.bFixMin | byte(l))
-	} else if ct.b8 > 0 && l < 256 {
-		e.w.writen2(ct.b8, uint8(l))
-	} else if l < 65536 {
-		e.w.writen1(ct.b16)
-		e.w.writen2(bigen.PutUint16(uint16(l)))
-	} else {
-		e.w.writen1(ct.b32)
-		e.w.writen4(bigen.PutUint32(uint32(l)))
-	}
-}
-
-func (d *msgpackDecDriverIO) DecodeNaked() {
-	if !d.bdRead {
-		d.readNextBd()
-	}
-	bd := d.bd
-	n := d.d.naked()
-	var decodeFurther bool
-
-	switch bd {
-	case mpNil:
-		n.v = valueTypeNil
-		d.bdRead = false
-	case mpFalse:
-		n.v = valueTypeBool
-		n.b = false
-	case mpTrue:
-		n.v = valueTypeBool
-		n.b = true
-
-	case mpFloat:
-		n.v = valueTypeFloat
-		n.f = float64(math.Float32frombits(bigen.Uint32(d.r.readn4())))
-	case mpDouble:
-		n.v = valueTypeFloat
-		n.f = math.Float64frombits(bigen.Uint64(d.r.readn8()))
-
-	case mpUint8:
-		n.v = valueTypeUint
-		n.u = uint64(d.r.readn1())
-	case mpUint16:
-		n.v = valueTypeUint
-		n.u = uint64(bigen.Uint16(d.r.readn2()))
-	case mpUint32:
-		n.v = valueTypeUint
-		n.u = uint64(bigen.Uint32(d.r.readn4()))
-	case mpUint64:
-		n.v = valueTypeUint
-		n.u = uint64(bigen.Uint64(d.r.readn8()))
-
-	case mpInt8:
-		n.v = valueTypeInt
-		n.i = int64(int8(d.r.readn1()))
-	case mpInt16:
-		n.v = valueTypeInt
-		n.i = int64(int16(bigen.Uint16(d.r.readn2())))
-	case mpInt32:
-		n.v = valueTypeInt
-		n.i = int64(int32(bigen.Uint32(d.r.readn4())))
-	case mpInt64:
-		n.v = valueTypeInt
-		n.i = int64(int64(bigen.Uint64(d.r.readn8())))
-
-	default:
-		switch {
-		case bd >= mpPosFixNumMin && bd <= mpPosFixNumMax:
-
-			n.v = valueTypeInt
-			n.i = int64(int8(bd))
-		case bd >= mpNegFixNumMin && bd <= mpNegFixNumMax:
-
-			n.v = valueTypeInt
-			n.i = int64(int8(bd))
-		case bd == mpStr8, bd == mpStr16, bd == mpStr32, bd >= mpFixStrMin && bd <= mpFixStrMax:
-			d.d.fauxUnionReadRawBytes(d, d.h.WriteExt, d.h.RawToString)
-
-		case bd == mpBin8, bd == mpBin16, bd == mpBin32:
-			d.d.fauxUnionReadRawBytes(d, false, d.h.RawToString)
-		case bd == mpArray16, bd == mpArray32, bd >= mpFixArrayMin && bd <= mpFixArrayMax:
-			n.v = valueTypeArray
-			decodeFurther = true
-		case bd == mpMap16, bd == mpMap32, bd >= mpFixMapMin && bd <= mpFixMapMax:
-			n.v = valueTypeMap
-			decodeFurther = true
-		case bd >= mpFixExt1 && bd <= mpFixExt16, bd >= mpExt8 && bd <= mpExt32:
-			n.v = valueTypeExt
-			clen := d.readExtLen()
-			n.u = uint64(d.r.readn1())
-			if n.u == uint64(mpTimeExtTagU) {
-				n.v = valueTypeTime
-				n.t = d.decodeTime(clen)
-			} else {
-				n.l = d.r.readx(uint(clen))
-			}
-		default:
-			halt.errorf("cannot infer value: %s: Ox%x/%d/%s", msgBadDesc, bd, bd, mpdesc(bd))
-		}
-	}
-	if !decodeFurther {
-		d.bdRead = false
-	}
-	if n.v == valueTypeUint && d.h.SignedInteger {
-		n.v = valueTypeInt
-		n.i = int64(n.u)
-	}
-}
-
-func (d *msgpackDecDriverIO) nextValueBytes() (v []byte) {
-	if !d.bdRead {
-		d.readNextBd()
-	}
-	d.r.startRecording()
-	d.nextValueBytesBdReadR()
-	v = d.r.stopRecording()
-	d.bdRead = false
-	return
-}
-
-func (d *msgpackDecDriverIO) nextValueBytesBdReadR() {
-	bd := d.bd
-
-	var clen uint
-
-	switch bd {
-	case mpNil, mpFalse, mpTrue:
-	case mpUint8, mpInt8:
-		d.r.readn1()
-	case mpUint16, mpInt16:
-		d.r.skip(2)
-	case mpFloat, mpUint32, mpInt32:
-		d.r.skip(4)
-	case mpDouble, mpUint64, mpInt64:
-		d.r.skip(8)
-	case mpStr8, mpBin8:
-		clen = uint(d.r.readn1())
-		d.r.skip(clen)
-	case mpStr16, mpBin16:
-		x := d.r.readn2()
-		clen = uint(bigen.Uint16(x))
-		d.r.skip(clen)
-	case mpStr32, mpBin32:
-		x := d.r.readn4()
-		clen = uint(bigen.Uint32(x))
-		d.r.skip(clen)
-	case mpFixExt1:
-		d.r.readn1()
-		d.r.readn1()
-	case mpFixExt2:
-		d.r.readn1()
-		d.r.skip(2)
-	case mpFixExt4:
-		d.r.readn1()
-		d.r.skip(4)
-	case mpFixExt8:
-		d.r.readn1()
-		d.r.skip(8)
-	case mpFixExt16:
-		d.r.readn1()
-		d.r.skip(16)
-	case mpExt8:
-		clen = uint(d.r.readn1())
-		d.r.readn1()
-		d.r.skip(clen)
-	case mpExt16:
-		x := d.r.readn2()
-		clen = uint(bigen.Uint16(x))
-		d.r.readn1()
-		d.r.skip(clen)
-	case mpExt32:
-		x := d.r.readn4()
-		clen = uint(bigen.Uint32(x))
-		d.r.readn1()
-		d.r.skip(clen)
-	case mpArray16:
-		x := d.r.readn2()
-		clen = uint(bigen.Uint16(x))
-		for i := uint(0); i < clen; i++ {
-			d.readNextBd()
-			d.nextValueBytesBdReadR()
-		}
-	case mpArray32:
-		x := d.r.readn4()
-		clen = uint(bigen.Uint32(x))
-		for i := uint(0); i < clen; i++ {
-			d.readNextBd()
-			d.nextValueBytesBdReadR()
-		}
-	case mpMap16:
-		x := d.r.readn2()
-		clen = uint(bigen.Uint16(x))
-		for i := uint(0); i < clen; i++ {
-			d.readNextBd()
-			d.nextValueBytesBdReadR()
-			d.readNextBd()
-			d.nextValueBytesBdReadR()
-		}
-	case mpMap32:
-		x := d.r.readn4()
-		clen = uint(bigen.Uint32(x))
-		for i := uint(0); i < clen; i++ {
-			d.readNextBd()
-			d.nextValueBytesBdReadR()
-			d.readNextBd()
-			d.nextValueBytesBdReadR()
-		}
-	default:
-		switch {
-		case bd >= mpPosFixNumMin && bd <= mpPosFixNumMax:
-		case bd >= mpNegFixNumMin && bd <= mpNegFixNumMax:
-		case bd >= mpFixStrMin && bd <= mpFixStrMax:
-			clen = uint(mpFixStrMin ^ bd)
-			d.r.skip(clen)
-		case bd >= mpFixArrayMin && bd <= mpFixArrayMax:
-			clen = uint(mpFixArrayMin ^ bd)
-			for i := uint(0); i < clen; i++ {
-				d.readNextBd()
-				d.nextValueBytesBdReadR()
-			}
-		case bd >= mpFixMapMin && bd <= mpFixMapMax:
-			clen = uint(mpFixMapMin ^ bd)
-			for i := uint(0); i < clen; i++ {
-				d.readNextBd()
-				d.nextValueBytesBdReadR()
-				d.readNextBd()
-				d.nextValueBytesBdReadR()
-			}
-		default:
-			halt.errorf("nextValueBytes: cannot infer value: %s: Ox%x/%d/%s", msgBadDesc, bd, bd, mpdesc(bd))
-		}
-	}
-	return
-}
-
-func (d *msgpackDecDriverIO) decFloat4Int32() (f float32) {
-	fbits := bigen.Uint32(d.r.readn4())
-	f = math.Float32frombits(fbits)
-	if !noFrac32(fbits) {
-		halt.errorf("assigning integer value from float32 with a fraction: %v", f)
-	}
-	return
-}
-
-func (d *msgpackDecDriverIO) decFloat4Int64() (f float64) {
-	fbits := bigen.Uint64(d.r.readn8())
-	f = math.Float64frombits(fbits)
-	if !noFrac64(fbits) {
-		halt.errorf("assigning integer value from float64 with a fraction: %v", f)
-	}
-	return
-}
-
-func (d *msgpackDecDriverIO) DecodeInt64() (i int64) {
-	if d.advanceNil() {
-		return
-	}
-	switch d.bd {
-	case mpUint8:
-		i = int64(uint64(d.r.readn1()))
-	case mpUint16:
-		i = int64(uint64(bigen.Uint16(d.r.readn2())))
-	case mpUint32:
-		i = int64(uint64(bigen.Uint32(d.r.readn4())))
-	case mpUint64:
-		i = int64(bigen.Uint64(d.r.readn8()))
-	case mpInt8:
-		i = int64(int8(d.r.readn1()))
-	case mpInt16:
-		i = int64(int16(bigen.Uint16(d.r.readn2())))
-	case mpInt32:
-		i = int64(int32(bigen.Uint32(d.r.readn4())))
-	case mpInt64:
-		i = int64(bigen.Uint64(d.r.readn8()))
-	case mpFloat:
-		i = int64(d.decFloat4Int32())
-	case mpDouble:
-		i = int64(d.decFloat4Int64())
-	default:
-		switch {
-		case d.bd >= mpPosFixNumMin && d.bd <= mpPosFixNumMax:
-			i = int64(int8(d.bd))
-		case d.bd >= mpNegFixNumMin && d.bd <= mpNegFixNumMax:
-			i = int64(int8(d.bd))
-		default:
-			halt.errorf("cannot decode signed integer: %s: %x/%s", msgBadDesc, d.bd, mpdesc(d.bd))
-		}
-	}
-	d.bdRead = false
-	return
-}
-
-func (d *msgpackDecDriverIO) DecodeUint64() (ui uint64) {
-	if d.advanceNil() {
-		return
-	}
-	switch d.bd {
-	case mpUint8:
-		ui = uint64(d.r.readn1())
-	case mpUint16:
-		ui = uint64(bigen.Uint16(d.r.readn2()))
-	case mpUint32:
-		ui = uint64(bigen.Uint32(d.r.readn4()))
-	case mpUint64:
-		ui = bigen.Uint64(d.r.readn8())
-	case mpInt8:
-		if i := int64(int8(d.r.readn1())); i >= 0 {
-			ui = uint64(i)
-		} else {
-			halt.errorf("assigning negative signed value: %v, to unsigned type", i)
-		}
-	case mpInt16:
-		if i := int64(int16(bigen.Uint16(d.r.readn2()))); i >= 0 {
-			ui = uint64(i)
-		} else {
-			halt.errorf("assigning negative signed value: %v, to unsigned type", i)
-		}
-	case mpInt32:
-		if i := int64(int32(bigen.Uint32(d.r.readn4()))); i >= 0 {
-			ui = uint64(i)
-		} else {
-			halt.errorf("assigning negative signed value: %v, to unsigned type", i)
-		}
-	case mpInt64:
-		if i := int64(bigen.Uint64(d.r.readn8())); i >= 0 {
-			ui = uint64(i)
-		} else {
-			halt.errorf("assigning negative signed value: %v, to unsigned type", i)
-		}
-	case mpFloat:
-		if f := d.decFloat4Int32(); f >= 0 {
-			ui = uint64(f)
-		} else {
-			halt.errorf("assigning negative float value: %v, to unsigned type", f)
-		}
-	case mpDouble:
-		if f := d.decFloat4Int64(); f >= 0 {
-			ui = uint64(f)
-		} else {
-			halt.errorf("assigning negative float value: %v, to unsigned type", f)
-		}
-	default:
-		switch {
-		case d.bd >= mpPosFixNumMin && d.bd <= mpPosFixNumMax:
-			ui = uint64(d.bd)
-		case d.bd >= mpNegFixNumMin && d.bd <= mpNegFixNumMax:
-			halt.errorf("assigning negative signed value: %v, to unsigned type", int(d.bd))
-		default:
-			halt.errorf("cannot decode unsigned integer: %s: %x/%s", msgBadDesc, d.bd, mpdesc(d.bd))
-		}
-	}
-	d.bdRead = false
-	return
-}
-
-func (d *msgpackDecDriverIO) DecodeFloat64() (f float64) {
-	if d.advanceNil() {
-		return
-	}
-	if d.bd == mpFloat {
-		f = float64(math.Float32frombits(bigen.Uint32(d.r.readn4())))
-	} else if d.bd == mpDouble {
-		f = math.Float64frombits(bigen.Uint64(d.r.readn8()))
-	} else {
-		f = float64(d.DecodeInt64())
-	}
-	d.bdRead = false
-	return
-}
-
-func (d *msgpackDecDriverIO) DecodeBool() (b bool) {
-	if d.advanceNil() {
-		return
-	}
-	if d.bd == mpFalse || d.bd == 0 {
-
-	} else if d.bd == mpTrue || d.bd == 1 {
-		b = true
-	} else {
-		halt.errorf("cannot decode bool: %s: %x/%s", msgBadDesc, d.bd, mpdesc(d.bd))
-	}
-	d.bdRead = false
-	return
-}
-
-func (d *msgpackDecDriverIO) DecodeBytes() (bs []byte, state dBytesAttachState) {
-	if d.advanceNil() {
-		return
-	}
-
-	var cond bool
-	bd := d.bd
-	var clen int
-	if bd == mpBin8 || bd == mpBin16 || bd == mpBin32 {
-		clen = d.readContainerLen(msgpackContainerBin)
-	} else if bd == mpStr8 || bd == mpStr16 || bd == mpStr32 ||
-		(bd >= mpFixStrMin && bd <= mpFixStrMax) {
-		clen = d.readContainerLen(msgpackContainerStr)
-	} else if bd == mpArray16 || bd == mpArray32 ||
-		(bd >= mpFixArrayMin && bd <= mpFixArrayMax) {
-		slen := d.ReadArrayStart()
-		bs, cond = usableByteSlice(d.d.buf, slen)
-		for i := 0; i < len(bs); i++ {
-			bs[i] = uint8(chkOvf.UintV(d.DecodeUint64(), 8))
-		}
-		for i := len(bs); i < slen; i++ {
-			bs = append(bs, uint8(chkOvf.UintV(d.DecodeUint64(), 8)))
-		}
-		if cond {
-			d.d.buf = bs
-		}
-		state = dBytesAttachBuffer
-		return
-	} else {
-		halt.errorf("invalid byte descriptor for decoding bytes, got: 0x%x", d.bd)
-	}
-
-	d.bdRead = false
-	bs, cond = d.r.readxb(uint(clen))
-	state = d.d.attachState(cond)
-	return
-}
-
-func (d *msgpackDecDriverIO) DecodeStringAsBytes() (out []byte, state dBytesAttachState) {
-	out, state = d.DecodeBytes()
-	if d.h.ValidateUnicode && !utf8.Valid(out) {
-		halt.errorf("DecodeStringAsBytes: invalid UTF-8: %s", out)
-	}
-	return
-}
-
-func (d *msgpackDecDriverIO) readNextBd() {
-	d.bd = d.r.readn1()
-	d.bdRead = true
-}
-
-func (d *msgpackDecDriverIO) advanceNil() (null bool) {
-	if !d.bdRead {
-		d.readNextBd()
-	}
-	if d.bd == mpNil {
-		d.bdRead = false
-		return true
-	}
-	return
-}
-
-func (d *msgpackDecDriverIO) TryNil() (v bool) {
-	return d.advanceNil()
-}
-
-func (d *msgpackDecDriverIO) ContainerType() (vt valueType) {
-	if !d.bdRead {
-		d.readNextBd()
-	}
-	bd := d.bd
-	if bd == mpNil {
-		d.bdRead = false
-		return valueTypeNil
-	} else if bd == mpBin8 || bd == mpBin16 || bd == mpBin32 {
-		return valueTypeBytes
-	} else if bd == mpStr8 || bd == mpStr16 || bd == mpStr32 ||
-		(bd >= mpFixStrMin && bd <= mpFixStrMax) {
-		if d.h.WriteExt || d.h.RawToString {
-			return valueTypeString
-		}
-		return valueTypeBytes
-	} else if bd == mpArray16 || bd == mpArray32 || (bd >= mpFixArrayMin && bd <= mpFixArrayMax) {
-		return valueTypeArray
-	} else if bd == mpMap16 || bd == mpMap32 || (bd >= mpFixMapMin && bd <= mpFixMapMax) {
-		return valueTypeMap
-	}
-	return valueTypeUnset
-}
-
-func (d *msgpackDecDriverIO) readContainerLen(ct msgpackContainerType) (clen int) {
-	bd := d.bd
-	if bd == ct.b8 {
-		clen = int(d.r.readn1())
-	} else if bd == ct.b16 {
-		clen = int(bigen.Uint16(d.r.readn2()))
-	} else if bd == ct.b32 {
-		clen = int(bigen.Uint32(d.r.readn4()))
-	} else if (ct.bFixMin & bd) == ct.bFixMin {
-		clen = int(ct.bFixMin ^ bd)
-	} else {
-		halt.errorf("cannot read container length: %s: hex: %x, decimal: %d", msgBadDesc, bd, bd)
-	}
-	d.bdRead = false
-	return
-}
-
-func (d *msgpackDecDriverIO) ReadMapStart() int {
-	if d.advanceNil() {
-		return containerLenNil
-	}
-	return d.readContainerLen(msgpackContainerMap)
-}
-
-func (d *msgpackDecDriverIO) ReadArrayStart() int {
-	if d.advanceNil() {
-		return containerLenNil
-	}
-	return d.readContainerLen(msgpackContainerList)
-}
-
-func (d *msgpackDecDriverIO) readExtLen() (clen int) {
-	switch d.bd {
-	case mpFixExt1:
-		clen = 1
-	case mpFixExt2:
-		clen = 2
-	case mpFixExt4:
-		clen = 4
-	case mpFixExt8:
-		clen = 8
-	case mpFixExt16:
-		clen = 16
-	case mpExt8:
-		clen = int(d.r.readn1())
-	case mpExt16:
-		clen = int(bigen.Uint16(d.r.readn2()))
-	case mpExt32:
-		clen = int(bigen.Uint32(d.r.readn4()))
-	default:
-		halt.errorf("decoding ext bytes: found unexpected byte: %x", d.bd)
-	}
-	return
-}
-
-func (d *msgpackDecDriverIO) DecodeTime() (t time.Time) {
-
-	if d.advanceNil() {
-		return
-	}
-	bd := d.bd
-	var clen int
-	if bd == mpBin8 || bd == mpBin16 || bd == mpBin32 {
-		clen = d.readContainerLen(msgpackContainerBin)
-	} else if bd == mpStr8 || bd == mpStr16 || bd == mpStr32 ||
-		(bd >= mpFixStrMin && bd <= mpFixStrMax) {
-		clen = d.readContainerLen(msgpackContainerStr)
-	} else {
-
-		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 {
-			halt.errorf("invalid stream for decoding time as extension: got 0x%x, 0x%x", d.bd, b2)
-		}
-	}
-	return d.decodeTime(clen)
-}
-
-func (d *msgpackDecDriverIO) decodeTime(clen int) (t time.Time) {
-	d.bdRead = false
-	switch clen {
-	case 4:
-		t = time.Unix(int64(bigen.Uint32(d.r.readn4())), 0).UTC()
-	case 8:
-		tv := bigen.Uint64(d.r.readn8())
-		t = time.Unix(int64(tv&0x00000003ffffffff), int64(tv>>34)).UTC()
-	case 12:
-		nsec := bigen.Uint32(d.r.readn4())
-		sec := bigen.Uint64(d.r.readn8())
-		t = time.Unix(int64(sec), int64(nsec)).UTC()
-	default:
-		halt.errorf("invalid length of bytes for decoding time - expecting 4 or 8 or 12, got %d", clen)
-	}
-	return
-}
-
-func (d *msgpackDecDriverIO) DecodeExt(rv interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
-	xbs, _, _, ok := d.decodeExtV(ext != nil, xtag)
-	if !ok {
-		return
-	}
-	if ext == SelfExt {
-		sideDecode(d.h, &d.h.sideDecPool, func(sd decoderI) { oneOffDecode(sd, rv, xbs, basetype, true) })
-	} else {
-		ext.ReadExt(rv, xbs)
-	}
-}
-
-func (d *msgpackDecDriverIO) DecodeRawExt(re *RawExt) {
-	xbs, realxtag, state, ok := d.decodeExtV(false, 0)
-	if !ok {
-		return
-	}
-	re.Tag = uint64(realxtag)
-	re.setData(xbs, state >= dBytesAttachViewZerocopy)
-}
-
-func (d *msgpackDecDriverIO) decodeExtV(verifyTag bool, xtagIn uint64) (xbs []byte, xtag byte, bstate dBytesAttachState, ok bool) {
-	if xtagIn > 0xff {
-		halt.errorf("ext: tag must be <= 0xff; got: %v", xtagIn)
-	}
-	if d.advanceNil() {
-		return
-	}
-	tag := uint8(xtagIn)
-	xbd := d.bd
-	if xbd == mpBin8 || xbd == mpBin16 || xbd == mpBin32 {
-		xbs, bstate = d.DecodeBytes()
-	} else if xbd == mpStr8 || xbd == mpStr16 || xbd == mpStr32 ||
-		(xbd >= mpFixStrMin && xbd <= mpFixStrMax) {
-		xbs, bstate = d.DecodeStringAsBytes()
-	} else {
-		clen := d.readExtLen()
-		xtag = d.r.readn1()
-		if verifyTag && xtag != tag {
-			halt.errorf("wrong extension tag - got %b, expecting %v", xtag, tag)
-		}
-		xbs, ok = d.r.readxb(uint(clen))
-		bstate = d.d.attachState(ok)
-
-	}
-	d.bdRead = false
-	ok = true
-	return
-}
-
-func (d *msgpackEncDriverIO) init(hh Handle, shared *encoderBase, enc encoderI) (fp interface{}) {
-	callMake(&d.w)
-	d.h = hh.(*MsgpackHandle)
-	d.e = shared
-	if shared.bytes {
-		fp = msgpackFpEncBytes
-	} else {
-		fp = msgpackFpEncIO
-	}
-
-	d.init2(enc)
-	return
-}
-
-func (e *msgpackEncDriverIO) writeBytesAsis(b []byte) { e.w.writeb(b) }
-
-func (e *msgpackEncDriverIO) writerEnd() { e.w.end() }
-
-func (e *msgpackEncDriverIO) resetOutBytes(out *[]byte) {
-	e.w.resetBytes(*out, out)
-}
-
-func (e *msgpackEncDriverIO) resetOutIO(out io.Writer) {
-	e.w.resetIO(out, e.h.WriterBufferSize, &e.e.blist)
-}
-
-func (d *msgpackDecDriverIO) init(hh Handle, shared *decoderBase, dec decoderI) (fp interface{}) {
-	callMake(&d.r)
-	d.h = hh.(*MsgpackHandle)
-	d.d = shared
-	if shared.bytes {
-		fp = msgpackFpDecBytes
-	} else {
-		fp = msgpackFpDecIO
-	}
-
-	d.init2(dec)
-	return
-}
-
-func (d *msgpackDecDriverIO) NumBytesRead() int {
-	return int(d.r.numread())
-}
-
-func (d *msgpackDecDriverIO) resetInBytes(in []byte) {
-	d.r.resetBytes(in)
-}
-
-func (d *msgpackDecDriverIO) resetInIO(r io.Reader) {
-	d.r.resetIO(r, d.h.ReaderBufferSize, d.h.MaxInitLen, &d.d.blist)
-}
-
-func (d *msgpackDecDriverIO) descBd() string {
-	return sprintf("%v (%s)", d.bd, mpdesc(d.bd))
-}
-
-func (d *msgpackDecDriverIO) DecodeFloat32() (f float32) {
-	return float32(chkOvf.Float32V(d.DecodeFloat64()))
-}