ugorji__go/codec/fast-path.go

// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
// Use of this source code is governed by a BSD-style license found in the LICENSE file.

// ************************************************************
// DO NOT EDIT.
// THIS FILE IS GENERATED BY RUNNING: go run gen-fast-path.go
// ************************************************************

package codec

// Fast path functions try to create a fast path encode or decode implementation
// for common maps and slices.
//
// We define the functions and register then in this single file
// so as not to pollute the encode.go and decode.go, and create a dependency in there.
// This file can be omitted without causing a build failure.
//
// The advantage of fast paths is:
//    - Many calls bypass reflection altogether
//
// Currently support
//    - slice of all builtin types,
//    - map of all builtin types to string or interface value
//    - symetrical maps of all builtin types (e.g. str-str, uint8-uint8)
// This should provide adequate "typical" implementations.
//
// Note that fast track decode functions must handle values for which an address cannot be obtained.
// For example:
//   m2 := map[string]int{}
//   p2 := []interface{}{m2}
//   // decoding into p2 will bomb if fast track functions do not treat like unaddressable.
//

import (
	"reflect"
)

func init() {
	if !fastpathEnabled {
		return // basically disable the fast path checks (since accessing empty map is basically free)
	}
	fx := func(i interface{}, fe func(*encFnInfo, reflect.Value), fd func(*decFnInfo, reflect.Value)) {
		xrt := reflect.TypeOf(i)
		xptr := reflect.ValueOf(xrt).Pointer()
		fastpathsTyp[xptr] = xrt
		fastpathsEnc[xptr] = fe
		fastpathsDec[xptr] = fd
	}

	fx([]interface{}(nil), (*encFnInfo).fastEncSliceIntf, (*decFnInfo).fastDecSliceIntf)
	fx([]string(nil), (*encFnInfo).fastEncSliceString, (*decFnInfo).fastDecSliceString)
	fx([]float32(nil), (*encFnInfo).fastEncSliceFloat32, (*decFnInfo).fastDecSliceFloat32)
	fx([]float64(nil), (*encFnInfo).fastEncSliceFloat64, (*decFnInfo).fastDecSliceFloat64)
	fx([]uint(nil), (*encFnInfo).fastEncSliceUint, (*decFnInfo).fastDecSliceUint)
	fx([]uint16(nil), (*encFnInfo).fastEncSliceUint16, (*decFnInfo).fastDecSliceUint16)
	fx([]uint32(nil), (*encFnInfo).fastEncSliceUint32, (*decFnInfo).fastDecSliceUint32)
	fx([]uint64(nil), (*encFnInfo).fastEncSliceUint64, (*decFnInfo).fastDecSliceUint64)
	fx([]int(nil), (*encFnInfo).fastEncSliceInt, (*decFnInfo).fastDecSliceInt)
	fx([]int8(nil), (*encFnInfo).fastEncSliceInt8, (*decFnInfo).fastDecSliceInt8)
	fx([]int16(nil), (*encFnInfo).fastEncSliceInt16, (*decFnInfo).fastDecSliceInt16)
	fx([]int32(nil), (*encFnInfo).fastEncSliceInt32, (*decFnInfo).fastDecSliceInt32)
	fx([]int64(nil), (*encFnInfo).fastEncSliceInt64, (*decFnInfo).fastDecSliceInt64)
	fx([]bool(nil), (*encFnInfo).fastEncSliceBool, (*decFnInfo).fastDecSliceBool)

	fx(map[interface{}]interface{}(nil), (*encFnInfo).fastEncMapIntfIntf, (*decFnInfo).fastDecMapIntfIntf)
	fx(map[interface{}]string(nil), (*encFnInfo).fastEncMapIntfString, (*decFnInfo).fastDecMapIntfString)
	fx(map[interface{}]uint(nil), (*encFnInfo).fastEncMapIntfUint, (*decFnInfo).fastDecMapIntfUint)
	fx(map[interface{}]uint32(nil), (*encFnInfo).fastEncMapIntfUint32, (*decFnInfo).fastDecMapIntfUint32)
	fx(map[interface{}]uint64(nil), (*encFnInfo).fastEncMapIntfUint64, (*decFnInfo).fastDecMapIntfUint64)
	fx(map[interface{}]int(nil), (*encFnInfo).fastEncMapIntfInt, (*decFnInfo).fastDecMapIntfInt)
	fx(map[interface{}]int32(nil), (*encFnInfo).fastEncMapIntfInt32, (*decFnInfo).fastDecMapIntfInt32)
	fx(map[interface{}]int64(nil), (*encFnInfo).fastEncMapIntfInt64, (*decFnInfo).fastDecMapIntfInt64)
	fx(map[string]interface{}(nil), (*encFnInfo).fastEncMapStringIntf, (*decFnInfo).fastDecMapStringIntf)
	fx(map[string]string(nil), (*encFnInfo).fastEncMapStringString, (*decFnInfo).fastDecMapStringString)
	fx(map[string]uint(nil), (*encFnInfo).fastEncMapStringUint, (*decFnInfo).fastDecMapStringUint)
	fx(map[string]uint32(nil), (*encFnInfo).fastEncMapStringUint32, (*decFnInfo).fastDecMapStringUint32)
	fx(map[string]uint64(nil), (*encFnInfo).fastEncMapStringUint64, (*decFnInfo).fastDecMapStringUint64)
	fx(map[string]int(nil), (*encFnInfo).fastEncMapStringInt, (*decFnInfo).fastDecMapStringInt)
	fx(map[string]int32(nil), (*encFnInfo).fastEncMapStringInt32, (*decFnInfo).fastDecMapStringInt32)
	fx(map[string]int64(nil), (*encFnInfo).fastEncMapStringInt64, (*decFnInfo).fastDecMapStringInt64)
	fx(map[float32]float32(nil), (*encFnInfo).fastEncMapFloat32Float32, (*decFnInfo).fastDecMapFloat32Float32)
	fx(map[float32]interface{}(nil), (*encFnInfo).fastEncMapFloat32Intf, (*decFnInfo).fastDecMapFloat32Intf)
	fx(map[float32]string(nil), (*encFnInfo).fastEncMapFloat32String, (*decFnInfo).fastDecMapFloat32String)
	fx(map[float32]uint(nil), (*encFnInfo).fastEncMapFloat32Uint, (*decFnInfo).fastDecMapFloat32Uint)
	fx(map[float32]uint32(nil), (*encFnInfo).fastEncMapFloat32Uint32, (*decFnInfo).fastDecMapFloat32Uint32)
	fx(map[float32]uint64(nil), (*encFnInfo).fastEncMapFloat32Uint64, (*decFnInfo).fastDecMapFloat32Uint64)
	fx(map[float32]int(nil), (*encFnInfo).fastEncMapFloat32Int, (*decFnInfo).fastDecMapFloat32Int)
	fx(map[float32]int32(nil), (*encFnInfo).fastEncMapFloat32Int32, (*decFnInfo).fastDecMapFloat32Int32)
	fx(map[float32]int64(nil), (*encFnInfo).fastEncMapFloat32Int64, (*decFnInfo).fastDecMapFloat32Int64)
	fx(map[float64]float64(nil), (*encFnInfo).fastEncMapFloat64Float64, (*decFnInfo).fastDecMapFloat64Float64)
	fx(map[float64]interface{}(nil), (*encFnInfo).fastEncMapFloat64Intf, (*decFnInfo).fastDecMapFloat64Intf)
	fx(map[float64]string(nil), (*encFnInfo).fastEncMapFloat64String, (*decFnInfo).fastDecMapFloat64String)
	fx(map[float64]uint(nil), (*encFnInfo).fastEncMapFloat64Uint, (*decFnInfo).fastDecMapFloat64Uint)
	fx(map[float64]uint32(nil), (*encFnInfo).fastEncMapFloat64Uint32, (*decFnInfo).fastDecMapFloat64Uint32)
	fx(map[float64]uint64(nil), (*encFnInfo).fastEncMapFloat64Uint64, (*decFnInfo).fastDecMapFloat64Uint64)
	fx(map[float64]int(nil), (*encFnInfo).fastEncMapFloat64Int, (*decFnInfo).fastDecMapFloat64Int)
	fx(map[float64]int32(nil), (*encFnInfo).fastEncMapFloat64Int32, (*decFnInfo).fastDecMapFloat64Int32)
	fx(map[float64]int64(nil), (*encFnInfo).fastEncMapFloat64Int64, (*decFnInfo).fastDecMapFloat64Int64)
	fx(map[uint]interface{}(nil), (*encFnInfo).fastEncMapUintIntf, (*decFnInfo).fastDecMapUintIntf)
	fx(map[uint]string(nil), (*encFnInfo).fastEncMapUintString, (*decFnInfo).fastDecMapUintString)
	fx(map[uint]uint(nil), (*encFnInfo).fastEncMapUintUint, (*decFnInfo).fastDecMapUintUint)
	fx(map[uint]uint32(nil), (*encFnInfo).fastEncMapUintUint32, (*decFnInfo).fastDecMapUintUint32)
	fx(map[uint]uint64(nil), (*encFnInfo).fastEncMapUintUint64, (*decFnInfo).fastDecMapUintUint64)
	fx(map[uint]int(nil), (*encFnInfo).fastEncMapUintInt, (*decFnInfo).fastDecMapUintInt)
	fx(map[uint]int32(nil), (*encFnInfo).fastEncMapUintInt32, (*decFnInfo).fastDecMapUintInt32)
	fx(map[uint]int64(nil), (*encFnInfo).fastEncMapUintInt64, (*decFnInfo).fastDecMapUintInt64)
	fx(map[uint8]uint8(nil), (*encFnInfo).fastEncMapUint8Uint8, (*decFnInfo).fastDecMapUint8Uint8)
	fx(map[uint8]interface{}(nil), (*encFnInfo).fastEncMapUint8Intf, (*decFnInfo).fastDecMapUint8Intf)
	fx(map[uint8]string(nil), (*encFnInfo).fastEncMapUint8String, (*decFnInfo).fastDecMapUint8String)
	fx(map[uint8]uint(nil), (*encFnInfo).fastEncMapUint8Uint, (*decFnInfo).fastDecMapUint8Uint)
	fx(map[uint8]uint32(nil), (*encFnInfo).fastEncMapUint8Uint32, (*decFnInfo).fastDecMapUint8Uint32)
	fx(map[uint8]uint64(nil), (*encFnInfo).fastEncMapUint8Uint64, (*decFnInfo).fastDecMapUint8Uint64)
	fx(map[uint8]int(nil), (*encFnInfo).fastEncMapUint8Int, (*decFnInfo).fastDecMapUint8Int)
	fx(map[uint8]int32(nil), (*encFnInfo).fastEncMapUint8Int32, (*decFnInfo).fastDecMapUint8Int32)
	fx(map[uint8]int64(nil), (*encFnInfo).fastEncMapUint8Int64, (*decFnInfo).fastDecMapUint8Int64)
	fx(map[uint16]uint16(nil), (*encFnInfo).fastEncMapUint16Uint16, (*decFnInfo).fastDecMapUint16Uint16)
	fx(map[uint16]interface{}(nil), (*encFnInfo).fastEncMapUint16Intf, (*decFnInfo).fastDecMapUint16Intf)
	fx(map[uint16]string(nil), (*encFnInfo).fastEncMapUint16String, (*decFnInfo).fastDecMapUint16String)
	fx(map[uint16]uint(nil), (*encFnInfo).fastEncMapUint16Uint, (*decFnInfo).fastDecMapUint16Uint)
	fx(map[uint16]uint32(nil), (*encFnInfo).fastEncMapUint16Uint32, (*decFnInfo).fastDecMapUint16Uint32)
	fx(map[uint16]uint64(nil), (*encFnInfo).fastEncMapUint16Uint64, (*decFnInfo).fastDecMapUint16Uint64)
	fx(map[uint16]int(nil), (*encFnInfo).fastEncMapUint16Int, (*decFnInfo).fastDecMapUint16Int)
	fx(map[uint16]int32(nil), (*encFnInfo).fastEncMapUint16Int32, (*decFnInfo).fastDecMapUint16Int32)
	fx(map[uint16]int64(nil), (*encFnInfo).fastEncMapUint16Int64, (*decFnInfo).fastDecMapUint16Int64)
	fx(map[uint32]interface{}(nil), (*encFnInfo).fastEncMapUint32Intf, (*decFnInfo).fastDecMapUint32Intf)
	fx(map[uint32]string(nil), (*encFnInfo).fastEncMapUint32String, (*decFnInfo).fastDecMapUint32String)
	fx(map[uint32]uint(nil), (*encFnInfo).fastEncMapUint32Uint, (*decFnInfo).fastDecMapUint32Uint)
	fx(map[uint32]uint32(nil), (*encFnInfo).fastEncMapUint32Uint32, (*decFnInfo).fastDecMapUint32Uint32)
	fx(map[uint32]uint64(nil), (*encFnInfo).fastEncMapUint32Uint64, (*decFnInfo).fastDecMapUint32Uint64)
	fx(map[uint32]int(nil), (*encFnInfo).fastEncMapUint32Int, (*decFnInfo).fastDecMapUint32Int)
	fx(map[uint32]int32(nil), (*encFnInfo).fastEncMapUint32Int32, (*decFnInfo).fastDecMapUint32Int32)
	fx(map[uint32]int64(nil), (*encFnInfo).fastEncMapUint32Int64, (*decFnInfo).fastDecMapUint32Int64)
	fx(map[uint64]interface{}(nil), (*encFnInfo).fastEncMapUint64Intf, (*decFnInfo).fastDecMapUint64Intf)
	fx(map[uint64]string(nil), (*encFnInfo).fastEncMapUint64String, (*decFnInfo).fastDecMapUint64String)
	fx(map[uint64]uint(nil), (*encFnInfo).fastEncMapUint64Uint, (*decFnInfo).fastDecMapUint64Uint)
	fx(map[uint64]uint32(nil), (*encFnInfo).fastEncMapUint64Uint32, (*decFnInfo).fastDecMapUint64Uint32)
	fx(map[uint64]uint64(nil), (*encFnInfo).fastEncMapUint64Uint64, (*decFnInfo).fastDecMapUint64Uint64)
	fx(map[uint64]int(nil), (*encFnInfo).fastEncMapUint64Int, (*decFnInfo).fastDecMapUint64Int)
	fx(map[uint64]int32(nil), (*encFnInfo).fastEncMapUint64Int32, (*decFnInfo).fastDecMapUint64Int32)
	fx(map[uint64]int64(nil), (*encFnInfo).fastEncMapUint64Int64, (*decFnInfo).fastDecMapUint64Int64)
	fx(map[int]interface{}(nil), (*encFnInfo).fastEncMapIntIntf, (*decFnInfo).fastDecMapIntIntf)
	fx(map[int]string(nil), (*encFnInfo).fastEncMapIntString, (*decFnInfo).fastDecMapIntString)
	fx(map[int]uint(nil), (*encFnInfo).fastEncMapIntUint, (*decFnInfo).fastDecMapIntUint)
	fx(map[int]uint32(nil), (*encFnInfo).fastEncMapIntUint32, (*decFnInfo).fastDecMapIntUint32)
	fx(map[int]uint64(nil), (*encFnInfo).fastEncMapIntUint64, (*decFnInfo).fastDecMapIntUint64)
	fx(map[int]int(nil), (*encFnInfo).fastEncMapIntInt, (*decFnInfo).fastDecMapIntInt)
	fx(map[int]int32(nil), (*encFnInfo).fastEncMapIntInt32, (*decFnInfo).fastDecMapIntInt32)
	fx(map[int]int64(nil), (*encFnInfo).fastEncMapIntInt64, (*decFnInfo).fastDecMapIntInt64)
	fx(map[int8]int8(nil), (*encFnInfo).fastEncMapInt8Int8, (*decFnInfo).fastDecMapInt8Int8)
	fx(map[int8]interface{}(nil), (*encFnInfo).fastEncMapInt8Intf, (*decFnInfo).fastDecMapInt8Intf)
	fx(map[int8]string(nil), (*encFnInfo).fastEncMapInt8String, (*decFnInfo).fastDecMapInt8String)
	fx(map[int8]uint(nil), (*encFnInfo).fastEncMapInt8Uint, (*decFnInfo).fastDecMapInt8Uint)
	fx(map[int8]uint32(nil), (*encFnInfo).fastEncMapInt8Uint32, (*decFnInfo).fastDecMapInt8Uint32)
	fx(map[int8]uint64(nil), (*encFnInfo).fastEncMapInt8Uint64, (*decFnInfo).fastDecMapInt8Uint64)
	fx(map[int8]int(nil), (*encFnInfo).fastEncMapInt8Int, (*decFnInfo).fastDecMapInt8Int)
	fx(map[int8]int32(nil), (*encFnInfo).fastEncMapInt8Int32, (*decFnInfo).fastDecMapInt8Int32)
	fx(map[int8]int64(nil), (*encFnInfo).fastEncMapInt8Int64, (*decFnInfo).fastDecMapInt8Int64)
	fx(map[int16]int16(nil), (*encFnInfo).fastEncMapInt16Int16, (*decFnInfo).fastDecMapInt16Int16)
	fx(map[int16]interface{}(nil), (*encFnInfo).fastEncMapInt16Intf, (*decFnInfo).fastDecMapInt16Intf)
	fx(map[int16]string(nil), (*encFnInfo).fastEncMapInt16String, (*decFnInfo).fastDecMapInt16String)
	fx(map[int16]uint(nil), (*encFnInfo).fastEncMapInt16Uint, (*decFnInfo).fastDecMapInt16Uint)
	fx(map[int16]uint32(nil), (*encFnInfo).fastEncMapInt16Uint32, (*decFnInfo).fastDecMapInt16Uint32)
	fx(map[int16]uint64(nil), (*encFnInfo).fastEncMapInt16Uint64, (*decFnInfo).fastDecMapInt16Uint64)
	fx(map[int16]int(nil), (*encFnInfo).fastEncMapInt16Int, (*decFnInfo).fastDecMapInt16Int)
	fx(map[int16]int32(nil), (*encFnInfo).fastEncMapInt16Int32, (*decFnInfo).fastDecMapInt16Int32)
	fx(map[int16]int64(nil), (*encFnInfo).fastEncMapInt16Int64, (*decFnInfo).fastDecMapInt16Int64)
	fx(map[int32]interface{}(nil), (*encFnInfo).fastEncMapInt32Intf, (*decFnInfo).fastDecMapInt32Intf)
	fx(map[int32]string(nil), (*encFnInfo).fastEncMapInt32String, (*decFnInfo).fastDecMapInt32String)
	fx(map[int32]uint(nil), (*encFnInfo).fastEncMapInt32Uint, (*decFnInfo).fastDecMapInt32Uint)
	fx(map[int32]uint32(nil), (*encFnInfo).fastEncMapInt32Uint32, (*decFnInfo).fastDecMapInt32Uint32)
	fx(map[int32]uint64(nil), (*encFnInfo).fastEncMapInt32Uint64, (*decFnInfo).fastDecMapInt32Uint64)
	fx(map[int32]int(nil), (*encFnInfo).fastEncMapInt32Int, (*decFnInfo).fastDecMapInt32Int)
	fx(map[int32]int32(nil), (*encFnInfo).fastEncMapInt32Int32, (*decFnInfo).fastDecMapInt32Int32)
	fx(map[int32]int64(nil), (*encFnInfo).fastEncMapInt32Int64, (*decFnInfo).fastDecMapInt32Int64)
	fx(map[int64]interface{}(nil), (*encFnInfo).fastEncMapInt64Intf, (*decFnInfo).fastDecMapInt64Intf)
	fx(map[int64]string(nil), (*encFnInfo).fastEncMapInt64String, (*decFnInfo).fastDecMapInt64String)
	fx(map[int64]uint(nil), (*encFnInfo).fastEncMapInt64Uint, (*decFnInfo).fastDecMapInt64Uint)
	fx(map[int64]uint32(nil), (*encFnInfo).fastEncMapInt64Uint32, (*decFnInfo).fastDecMapInt64Uint32)
	fx(map[int64]uint64(nil), (*encFnInfo).fastEncMapInt64Uint64, (*decFnInfo).fastDecMapInt64Uint64)
	fx(map[int64]int(nil), (*encFnInfo).fastEncMapInt64Int, (*decFnInfo).fastDecMapInt64Int)
	fx(map[int64]int32(nil), (*encFnInfo).fastEncMapInt64Int32, (*decFnInfo).fastDecMapInt64Int32)
	fx(map[int64]int64(nil), (*encFnInfo).fastEncMapInt64Int64, (*decFnInfo).fastDecMapInt64Int64)
	fx(map[bool]bool(nil), (*encFnInfo).fastEncMapBoolBool, (*decFnInfo).fastDecMapBoolBool)
	fx(map[bool]interface{}(nil), (*encFnInfo).fastEncMapBoolIntf, (*decFnInfo).fastDecMapBoolIntf)
	fx(map[bool]string(nil), (*encFnInfo).fastEncMapBoolString, (*decFnInfo).fastDecMapBoolString)
	fx(map[bool]uint(nil), (*encFnInfo).fastEncMapBoolUint, (*decFnInfo).fastDecMapBoolUint)
	fx(map[bool]uint32(nil), (*encFnInfo).fastEncMapBoolUint32, (*decFnInfo).fastDecMapBoolUint32)
	fx(map[bool]uint64(nil), (*encFnInfo).fastEncMapBoolUint64, (*decFnInfo).fastDecMapBoolUint64)
	fx(map[bool]int(nil), (*encFnInfo).fastEncMapBoolInt, (*decFnInfo).fastDecMapBoolInt)
	fx(map[bool]int32(nil), (*encFnInfo).fastEncMapBoolInt32, (*decFnInfo).fastDecMapBoolInt32)
	fx(map[bool]int64(nil), (*encFnInfo).fastEncMapBoolInt64, (*decFnInfo).fastDecMapBoolInt64)

}

// -- encode

func (f *encFnInfo) fastEncSliceIntf(rv reflect.Value) {
	v := rv.Interface().([]interface{})
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeArrayStart(len(v))
	for j, v2 := range v {
		if j > 0 {
			f.ee.encodeArrayEntrySeparator()
		}
		f.e.encode(v2)
	}
	f.ee.encodeArrayEnd()
}

func (f *encFnInfo) fastEncSliceString(rv reflect.Value) {
	v := rv.Interface().([]string)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeArrayStart(len(v))
	for j, v2 := range v {
		if j > 0 {
			f.ee.encodeArrayEntrySeparator()
		}
		f.ee.encodeString(c_UTF8, v2)
	}
	f.ee.encodeArrayEnd()
}

func (f *encFnInfo) fastEncSliceFloat32(rv reflect.Value) {
	v := rv.Interface().([]float32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeArrayStart(len(v))
	for j, v2 := range v {
		if j > 0 {
			f.ee.encodeArrayEntrySeparator()
		}
		f.ee.encodeFloat32(v2)
	}
	f.ee.encodeArrayEnd()
}

func (f *encFnInfo) fastEncSliceFloat64(rv reflect.Value) {
	v := rv.Interface().([]float64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeArrayStart(len(v))
	for j, v2 := range v {
		if j > 0 {
			f.ee.encodeArrayEntrySeparator()
		}
		f.ee.encodeFloat64(v2)
	}
	f.ee.encodeArrayEnd()
}

func (f *encFnInfo) fastEncSliceUint(rv reflect.Value) {
	v := rv.Interface().([]uint)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeArrayStart(len(v))
	for j, v2 := range v {
		if j > 0 {
			f.ee.encodeArrayEntrySeparator()
		}
		f.ee.encodeUint(uint64(v2))
	}
	f.ee.encodeArrayEnd()
}

func (f *encFnInfo) fastEncSliceUint16(rv reflect.Value) {
	v := rv.Interface().([]uint16)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeArrayStart(len(v))
	for j, v2 := range v {
		if j > 0 {
			f.ee.encodeArrayEntrySeparator()
		}
		f.ee.encodeUint(uint64(v2))
	}
	f.ee.encodeArrayEnd()
}

func (f *encFnInfo) fastEncSliceUint32(rv reflect.Value) {
	v := rv.Interface().([]uint32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeArrayStart(len(v))
	for j, v2 := range v {
		if j > 0 {
			f.ee.encodeArrayEntrySeparator()
		}
		f.ee.encodeUint(uint64(v2))
	}
	f.ee.encodeArrayEnd()
}

func (f *encFnInfo) fastEncSliceUint64(rv reflect.Value) {
	v := rv.Interface().([]uint64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeArrayStart(len(v))
	for j, v2 := range v {
		if j > 0 {
			f.ee.encodeArrayEntrySeparator()
		}
		f.ee.encodeUint(uint64(v2))
	}
	f.ee.encodeArrayEnd()
}

func (f *encFnInfo) fastEncSliceInt(rv reflect.Value) {
	v := rv.Interface().([]int)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeArrayStart(len(v))
	for j, v2 := range v {
		if j > 0 {
			f.ee.encodeArrayEntrySeparator()
		}
		f.ee.encodeInt(int64(v2))
	}
	f.ee.encodeArrayEnd()
}

func (f *encFnInfo) fastEncSliceInt8(rv reflect.Value) {
	v := rv.Interface().([]int8)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeArrayStart(len(v))
	for j, v2 := range v {
		if j > 0 {
			f.ee.encodeArrayEntrySeparator()
		}
		f.ee.encodeInt(int64(v2))
	}
	f.ee.encodeArrayEnd()
}

func (f *encFnInfo) fastEncSliceInt16(rv reflect.Value) {
	v := rv.Interface().([]int16)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeArrayStart(len(v))
	for j, v2 := range v {
		if j > 0 {
			f.ee.encodeArrayEntrySeparator()
		}
		f.ee.encodeInt(int64(v2))
	}
	f.ee.encodeArrayEnd()
}

func (f *encFnInfo) fastEncSliceInt32(rv reflect.Value) {
	v := rv.Interface().([]int32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeArrayStart(len(v))
	for j, v2 := range v {
		if j > 0 {
			f.ee.encodeArrayEntrySeparator()
		}
		f.ee.encodeInt(int64(v2))
	}
	f.ee.encodeArrayEnd()
}

func (f *encFnInfo) fastEncSliceInt64(rv reflect.Value) {
	v := rv.Interface().([]int64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeArrayStart(len(v))
	for j, v2 := range v {
		if j > 0 {
			f.ee.encodeArrayEntrySeparator()
		}
		f.ee.encodeInt(int64(v2))
	}
	f.ee.encodeArrayEnd()
}

func (f *encFnInfo) fastEncSliceBool(rv reflect.Value) {
	v := rv.Interface().([]bool)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeArrayStart(len(v))
	for j, v2 := range v {
		if j > 0 {
			f.ee.encodeArrayEntrySeparator()
		}
		f.ee.encodeBool(v2)
	}
	f.ee.encodeArrayEnd()
}

func (f *encFnInfo) fastEncMapIntfIntf(rv reflect.Value) {
	v := rv.Interface().(map[interface{}]interface{})
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.e.encode(k2)
		f.ee.encodeMapKVSeparator()
		f.e.encode(v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapIntfString(rv reflect.Value) {
	v := rv.Interface().(map[interface{}]string)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.e.encode(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeString(c_UTF8, v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapIntfUint(rv reflect.Value) {
	v := rv.Interface().(map[interface{}]uint)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.e.encode(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapIntfUint32(rv reflect.Value) {
	v := rv.Interface().(map[interface{}]uint32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.e.encode(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapIntfUint64(rv reflect.Value) {
	v := rv.Interface().(map[interface{}]uint64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.e.encode(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapIntfInt(rv reflect.Value) {
	v := rv.Interface().(map[interface{}]int)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.e.encode(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapIntfInt32(rv reflect.Value) {
	v := rv.Interface().(map[interface{}]int32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.e.encode(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapIntfInt64(rv reflect.Value) {
	v := rv.Interface().(map[interface{}]int64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.e.encode(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapStringIntf(rv reflect.Value) {
	v := rv.Interface().(map[string]interface{})
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))
	asSymbols := f.e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		if asSymbols {
			f.ee.encodeSymbol(k2)
		} else {
			f.ee.encodeString(c_UTF8, k2)
		}
		f.ee.encodeMapKVSeparator()
		f.e.encode(v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapStringString(rv reflect.Value) {
	v := rv.Interface().(map[string]string)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))
	asSymbols := f.e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		if asSymbols {
			f.ee.encodeSymbol(k2)
		} else {
			f.ee.encodeString(c_UTF8, k2)
		}
		f.ee.encodeMapKVSeparator()
		f.ee.encodeString(c_UTF8, v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapStringUint(rv reflect.Value) {
	v := rv.Interface().(map[string]uint)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))
	asSymbols := f.e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		if asSymbols {
			f.ee.encodeSymbol(k2)
		} else {
			f.ee.encodeString(c_UTF8, k2)
		}
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapStringUint32(rv reflect.Value) {
	v := rv.Interface().(map[string]uint32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))
	asSymbols := f.e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		if asSymbols {
			f.ee.encodeSymbol(k2)
		} else {
			f.ee.encodeString(c_UTF8, k2)
		}
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapStringUint64(rv reflect.Value) {
	v := rv.Interface().(map[string]uint64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))
	asSymbols := f.e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		if asSymbols {
			f.ee.encodeSymbol(k2)
		} else {
			f.ee.encodeString(c_UTF8, k2)
		}
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapStringInt(rv reflect.Value) {
	v := rv.Interface().(map[string]int)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))
	asSymbols := f.e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		if asSymbols {
			f.ee.encodeSymbol(k2)
		} else {
			f.ee.encodeString(c_UTF8, k2)
		}
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapStringInt32(rv reflect.Value) {
	v := rv.Interface().(map[string]int32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))
	asSymbols := f.e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		if asSymbols {
			f.ee.encodeSymbol(k2)
		} else {
			f.ee.encodeString(c_UTF8, k2)
		}
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapStringInt64(rv reflect.Value) {
	v := rv.Interface().(map[string]int64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))
	asSymbols := f.e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		if asSymbols {
			f.ee.encodeSymbol(k2)
		} else {
			f.ee.encodeString(c_UTF8, k2)
		}
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapFloat32Float32(rv reflect.Value) {
	v := rv.Interface().(map[float32]float32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeFloat32(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeFloat32(v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapFloat32Intf(rv reflect.Value) {
	v := rv.Interface().(map[float32]interface{})
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeFloat32(k2)
		f.ee.encodeMapKVSeparator()
		f.e.encode(v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapFloat32String(rv reflect.Value) {
	v := rv.Interface().(map[float32]string)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeFloat32(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeString(c_UTF8, v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapFloat32Uint(rv reflect.Value) {
	v := rv.Interface().(map[float32]uint)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeFloat32(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapFloat32Uint32(rv reflect.Value) {
	v := rv.Interface().(map[float32]uint32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeFloat32(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapFloat32Uint64(rv reflect.Value) {
	v := rv.Interface().(map[float32]uint64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeFloat32(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapFloat32Int(rv reflect.Value) {
	v := rv.Interface().(map[float32]int)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeFloat32(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapFloat32Int32(rv reflect.Value) {
	v := rv.Interface().(map[float32]int32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeFloat32(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapFloat32Int64(rv reflect.Value) {
	v := rv.Interface().(map[float32]int64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeFloat32(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapFloat64Float64(rv reflect.Value) {
	v := rv.Interface().(map[float64]float64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeFloat64(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeFloat64(v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapFloat64Intf(rv reflect.Value) {
	v := rv.Interface().(map[float64]interface{})
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeFloat64(k2)
		f.ee.encodeMapKVSeparator()
		f.e.encode(v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapFloat64String(rv reflect.Value) {
	v := rv.Interface().(map[float64]string)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeFloat64(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeString(c_UTF8, v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapFloat64Uint(rv reflect.Value) {
	v := rv.Interface().(map[float64]uint)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeFloat64(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapFloat64Uint32(rv reflect.Value) {
	v := rv.Interface().(map[float64]uint32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeFloat64(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapFloat64Uint64(rv reflect.Value) {
	v := rv.Interface().(map[float64]uint64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeFloat64(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapFloat64Int(rv reflect.Value) {
	v := rv.Interface().(map[float64]int)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeFloat64(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapFloat64Int32(rv reflect.Value) {
	v := rv.Interface().(map[float64]int32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeFloat64(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapFloat64Int64(rv reflect.Value) {
	v := rv.Interface().(map[float64]int64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeFloat64(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUintIntf(rv reflect.Value) {
	v := rv.Interface().(map[uint]interface{})
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.e.encode(v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUintString(rv reflect.Value) {
	v := rv.Interface().(map[uint]string)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeString(c_UTF8, v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUintUint(rv reflect.Value) {
	v := rv.Interface().(map[uint]uint)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUintUint32(rv reflect.Value) {
	v := rv.Interface().(map[uint]uint32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUintUint64(rv reflect.Value) {
	v := rv.Interface().(map[uint]uint64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUintInt(rv reflect.Value) {
	v := rv.Interface().(map[uint]int)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUintInt32(rv reflect.Value) {
	v := rv.Interface().(map[uint]int32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUintInt64(rv reflect.Value) {
	v := rv.Interface().(map[uint]int64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint8Uint8(rv reflect.Value) {
	v := rv.Interface().(map[uint8]uint8)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint8Intf(rv reflect.Value) {
	v := rv.Interface().(map[uint8]interface{})
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.e.encode(v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint8String(rv reflect.Value) {
	v := rv.Interface().(map[uint8]string)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeString(c_UTF8, v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint8Uint(rv reflect.Value) {
	v := rv.Interface().(map[uint8]uint)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint8Uint32(rv reflect.Value) {
	v := rv.Interface().(map[uint8]uint32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint8Uint64(rv reflect.Value) {
	v := rv.Interface().(map[uint8]uint64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint8Int(rv reflect.Value) {
	v := rv.Interface().(map[uint8]int)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint8Int32(rv reflect.Value) {
	v := rv.Interface().(map[uint8]int32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint8Int64(rv reflect.Value) {
	v := rv.Interface().(map[uint8]int64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint16Uint16(rv reflect.Value) {
	v := rv.Interface().(map[uint16]uint16)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint16Intf(rv reflect.Value) {
	v := rv.Interface().(map[uint16]interface{})
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.e.encode(v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint16String(rv reflect.Value) {
	v := rv.Interface().(map[uint16]string)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeString(c_UTF8, v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint16Uint(rv reflect.Value) {
	v := rv.Interface().(map[uint16]uint)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint16Uint32(rv reflect.Value) {
	v := rv.Interface().(map[uint16]uint32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint16Uint64(rv reflect.Value) {
	v := rv.Interface().(map[uint16]uint64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint16Int(rv reflect.Value) {
	v := rv.Interface().(map[uint16]int)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint16Int32(rv reflect.Value) {
	v := rv.Interface().(map[uint16]int32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint16Int64(rv reflect.Value) {
	v := rv.Interface().(map[uint16]int64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint32Intf(rv reflect.Value) {
	v := rv.Interface().(map[uint32]interface{})
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.e.encode(v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint32String(rv reflect.Value) {
	v := rv.Interface().(map[uint32]string)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeString(c_UTF8, v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint32Uint(rv reflect.Value) {
	v := rv.Interface().(map[uint32]uint)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint32Uint32(rv reflect.Value) {
	v := rv.Interface().(map[uint32]uint32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint32Uint64(rv reflect.Value) {
	v := rv.Interface().(map[uint32]uint64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint32Int(rv reflect.Value) {
	v := rv.Interface().(map[uint32]int)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint32Int32(rv reflect.Value) {
	v := rv.Interface().(map[uint32]int32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint32Int64(rv reflect.Value) {
	v := rv.Interface().(map[uint32]int64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint64Intf(rv reflect.Value) {
	v := rv.Interface().(map[uint64]interface{})
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.e.encode(v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint64String(rv reflect.Value) {
	v := rv.Interface().(map[uint64]string)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeString(c_UTF8, v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint64Uint(rv reflect.Value) {
	v := rv.Interface().(map[uint64]uint)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint64Uint32(rv reflect.Value) {
	v := rv.Interface().(map[uint64]uint32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint64Uint64(rv reflect.Value) {
	v := rv.Interface().(map[uint64]uint64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint64Int(rv reflect.Value) {
	v := rv.Interface().(map[uint64]int)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint64Int32(rv reflect.Value) {
	v := rv.Interface().(map[uint64]int32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapUint64Int64(rv reflect.Value) {
	v := rv.Interface().(map[uint64]int64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeUint(uint64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapIntIntf(rv reflect.Value) {
	v := rv.Interface().(map[int]interface{})
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.e.encode(v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapIntString(rv reflect.Value) {
	v := rv.Interface().(map[int]string)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeString(c_UTF8, v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapIntUint(rv reflect.Value) {
	v := rv.Interface().(map[int]uint)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapIntUint32(rv reflect.Value) {
	v := rv.Interface().(map[int]uint32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapIntUint64(rv reflect.Value) {
	v := rv.Interface().(map[int]uint64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapIntInt(rv reflect.Value) {
	v := rv.Interface().(map[int]int)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapIntInt32(rv reflect.Value) {
	v := rv.Interface().(map[int]int32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapIntInt64(rv reflect.Value) {
	v := rv.Interface().(map[int]int64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt8Int8(rv reflect.Value) {
	v := rv.Interface().(map[int8]int8)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt8Intf(rv reflect.Value) {
	v := rv.Interface().(map[int8]interface{})
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.e.encode(v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt8String(rv reflect.Value) {
	v := rv.Interface().(map[int8]string)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeString(c_UTF8, v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt8Uint(rv reflect.Value) {
	v := rv.Interface().(map[int8]uint)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt8Uint32(rv reflect.Value) {
	v := rv.Interface().(map[int8]uint32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt8Uint64(rv reflect.Value) {
	v := rv.Interface().(map[int8]uint64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt8Int(rv reflect.Value) {
	v := rv.Interface().(map[int8]int)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt8Int32(rv reflect.Value) {
	v := rv.Interface().(map[int8]int32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt8Int64(rv reflect.Value) {
	v := rv.Interface().(map[int8]int64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt16Int16(rv reflect.Value) {
	v := rv.Interface().(map[int16]int16)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt16Intf(rv reflect.Value) {
	v := rv.Interface().(map[int16]interface{})
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.e.encode(v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt16String(rv reflect.Value) {
	v := rv.Interface().(map[int16]string)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeString(c_UTF8, v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt16Uint(rv reflect.Value) {
	v := rv.Interface().(map[int16]uint)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt16Uint32(rv reflect.Value) {
	v := rv.Interface().(map[int16]uint32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt16Uint64(rv reflect.Value) {
	v := rv.Interface().(map[int16]uint64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt16Int(rv reflect.Value) {
	v := rv.Interface().(map[int16]int)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt16Int32(rv reflect.Value) {
	v := rv.Interface().(map[int16]int32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt16Int64(rv reflect.Value) {
	v := rv.Interface().(map[int16]int64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt32Intf(rv reflect.Value) {
	v := rv.Interface().(map[int32]interface{})
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.e.encode(v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt32String(rv reflect.Value) {
	v := rv.Interface().(map[int32]string)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeString(c_UTF8, v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt32Uint(rv reflect.Value) {
	v := rv.Interface().(map[int32]uint)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt32Uint32(rv reflect.Value) {
	v := rv.Interface().(map[int32]uint32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt32Uint64(rv reflect.Value) {
	v := rv.Interface().(map[int32]uint64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt32Int(rv reflect.Value) {
	v := rv.Interface().(map[int32]int)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt32Int32(rv reflect.Value) {
	v := rv.Interface().(map[int32]int32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt32Int64(rv reflect.Value) {
	v := rv.Interface().(map[int32]int64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt64Intf(rv reflect.Value) {
	v := rv.Interface().(map[int64]interface{})
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.e.encode(v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt64String(rv reflect.Value) {
	v := rv.Interface().(map[int64]string)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeString(c_UTF8, v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt64Uint(rv reflect.Value) {
	v := rv.Interface().(map[int64]uint)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt64Uint32(rv reflect.Value) {
	v := rv.Interface().(map[int64]uint32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt64Uint64(rv reflect.Value) {
	v := rv.Interface().(map[int64]uint64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt64Int(rv reflect.Value) {
	v := rv.Interface().(map[int64]int)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt64Int32(rv reflect.Value) {
	v := rv.Interface().(map[int64]int32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapInt64Int64(rv reflect.Value) {
	v := rv.Interface().(map[int64]int64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeInt(int64(k2))
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapBoolBool(rv reflect.Value) {
	v := rv.Interface().(map[bool]bool)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeBool(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeBool(v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapBoolIntf(rv reflect.Value) {
	v := rv.Interface().(map[bool]interface{})
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeBool(k2)
		f.ee.encodeMapKVSeparator()
		f.e.encode(v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapBoolString(rv reflect.Value) {
	v := rv.Interface().(map[bool]string)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeBool(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeString(c_UTF8, v2)
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapBoolUint(rv reflect.Value) {
	v := rv.Interface().(map[bool]uint)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeBool(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapBoolUint32(rv reflect.Value) {
	v := rv.Interface().(map[bool]uint32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeBool(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapBoolUint64(rv reflect.Value) {
	v := rv.Interface().(map[bool]uint64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeBool(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeUint(uint64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapBoolInt(rv reflect.Value) {
	v := rv.Interface().(map[bool]int)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeBool(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapBoolInt32(rv reflect.Value) {
	v := rv.Interface().(map[bool]int32)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeBool(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

func (f *encFnInfo) fastEncMapBoolInt64(rv reflect.Value) {
	v := rv.Interface().(map[bool]int64)
	if v == nil {
		f.ee.encodeNil()
		return
	}
	f.ee.encodeMapStart(len(v))

	j := 0
	for k2, v2 := range v {
		if j > 0 {
			f.ee.encodeMapEntrySeparator()
		}
		f.ee.encodeBool(k2)
		f.ee.encodeMapKVSeparator()
		f.ee.encodeInt(int64(v2))
		j++
	}
	f.ee.encodeMapEnd()
}

// -- decode

func (f *decFnInfo) fastDecSliceIntf(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp *[]interface{}
	var v []interface{}
	if xaddr {
		vp = rv.Addr().Interface().(*[]interface{})
		v = *vp
	} else {
		v = rv.Interface().([]interface{})
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing.
		return
	}

	slh := decSliceHelper{dd: f.dd}
	containerLenS := slh.start()
	if containerLenS == 0 {
		if v == nil {
			v = []interface{}{}
		} else {
			v = v[:0]
		}
		*vp = v
		f.dd.readArrayEnd()
		return
	}
	if v == nil {
		if containerLenS > 0 {
			v = make([]interface{}, containerLenS, containerLenS)
		} else {
			v = make([]interface{}, 0, 4)
		}
	} else if containerLenS > cap(v) {
		if f.array {
			decErr(msgDecCannotExpandArr, cap(v), containerLenS)
		}
		s := make([]interface{}, containerLenS, containerLenS)
		copy(s, v)
		v = s
	} else if containerLenS > len(v) {
		v = v[:containerLenS]
	}
	// for j := 0; j < containerLenS; j++ {
	for j := 0; ; j++ {
		if containerLenS >= 0 {
			if j >= containerLenS {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j >= len(v) {
			v = append(v, nil)
		}
		if j > 0 {
			slh.sep(j)
		}
		f.d.decode(&v[j])

	}
	slh.end()
	if xaddr {
		*vp = v
	}
}

func (f *decFnInfo) fastDecSliceString(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp *[]string
	var v []string
	if xaddr {
		vp = rv.Addr().Interface().(*[]string)
		v = *vp
	} else {
		v = rv.Interface().([]string)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing.
		return
	}

	slh := decSliceHelper{dd: f.dd}
	containerLenS := slh.start()
	if containerLenS == 0 {
		if v == nil {
			v = []string{}
		} else {
			v = v[:0]
		}
		*vp = v
		f.dd.readArrayEnd()
		return
	}
	if v == nil {
		if containerLenS > 0 {
			v = make([]string, containerLenS, containerLenS)
		} else {
			v = make([]string, 0, 4)
		}
	} else if containerLenS > cap(v) {
		if f.array {
			decErr(msgDecCannotExpandArr, cap(v), containerLenS)
		}
		s := make([]string, containerLenS, containerLenS)
		copy(s, v)
		v = s
	} else if containerLenS > len(v) {
		v = v[:containerLenS]
	}
	// for j := 0; j < containerLenS; j++ {
	for j := 0; ; j++ {
		if containerLenS >= 0 {
			if j >= containerLenS {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j >= len(v) {
			v = append(v, "")
		}
		if j > 0 {
			slh.sep(j)
		}
		f.dd.initReadNext()
		v[j] = f.dd.decodeString()

	}
	slh.end()
	if xaddr {
		*vp = v
	}
}

func (f *decFnInfo) fastDecSliceFloat32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp *[]float32
	var v []float32
	if xaddr {
		vp = rv.Addr().Interface().(*[]float32)
		v = *vp
	} else {
		v = rv.Interface().([]float32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing.
		return
	}

	slh := decSliceHelper{dd: f.dd}
	containerLenS := slh.start()
	if containerLenS == 0 {
		if v == nil {
			v = []float32{}
		} else {
			v = v[:0]
		}
		*vp = v
		f.dd.readArrayEnd()
		return
	}
	if v == nil {
		if containerLenS > 0 {
			v = make([]float32, containerLenS, containerLenS)
		} else {
			v = make([]float32, 0, 4)
		}
	} else if containerLenS > cap(v) {
		if f.array {
			decErr(msgDecCannotExpandArr, cap(v), containerLenS)
		}
		s := make([]float32, containerLenS, containerLenS)
		copy(s, v)
		v = s
	} else if containerLenS > len(v) {
		v = v[:containerLenS]
	}
	// for j := 0; j < containerLenS; j++ {
	for j := 0; ; j++ {
		if containerLenS >= 0 {
			if j >= containerLenS {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j >= len(v) {
			v = append(v, 0)
		}
		if j > 0 {
			slh.sep(j)
		}
		f.dd.initReadNext()
		v[j] = float32(f.dd.decodeFloat(true))

	}
	slh.end()
	if xaddr {
		*vp = v
	}
}

func (f *decFnInfo) fastDecSliceFloat64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp *[]float64
	var v []float64
	if xaddr {
		vp = rv.Addr().Interface().(*[]float64)
		v = *vp
	} else {
		v = rv.Interface().([]float64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing.
		return
	}

	slh := decSliceHelper{dd: f.dd}
	containerLenS := slh.start()
	if containerLenS == 0 {
		if v == nil {
			v = []float64{}
		} else {
			v = v[:0]
		}
		*vp = v
		f.dd.readArrayEnd()
		return
	}
	if v == nil {
		if containerLenS > 0 {
			v = make([]float64, containerLenS, containerLenS)
		} else {
			v = make([]float64, 0, 4)
		}
	} else if containerLenS > cap(v) {
		if f.array {
			decErr(msgDecCannotExpandArr, cap(v), containerLenS)
		}
		s := make([]float64, containerLenS, containerLenS)
		copy(s, v)
		v = s
	} else if containerLenS > len(v) {
		v = v[:containerLenS]
	}
	// for j := 0; j < containerLenS; j++ {
	for j := 0; ; j++ {
		if containerLenS >= 0 {
			if j >= containerLenS {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j >= len(v) {
			v = append(v, 0)
		}
		if j > 0 {
			slh.sep(j)
		}
		f.dd.initReadNext()
		v[j] = f.dd.decodeFloat(false)

	}
	slh.end()
	if xaddr {
		*vp = v
	}
}

func (f *decFnInfo) fastDecSliceUint(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp *[]uint
	var v []uint
	if xaddr {
		vp = rv.Addr().Interface().(*[]uint)
		v = *vp
	} else {
		v = rv.Interface().([]uint)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing.
		return
	}

	slh := decSliceHelper{dd: f.dd}
	containerLenS := slh.start()
	if containerLenS == 0 {
		if v == nil {
			v = []uint{}
		} else {
			v = v[:0]
		}
		*vp = v
		f.dd.readArrayEnd()
		return
	}
	if v == nil {
		if containerLenS > 0 {
			v = make([]uint, containerLenS, containerLenS)
		} else {
			v = make([]uint, 0, 4)
		}
	} else if containerLenS > cap(v) {
		if f.array {
			decErr(msgDecCannotExpandArr, cap(v), containerLenS)
		}
		s := make([]uint, containerLenS, containerLenS)
		copy(s, v)
		v = s
	} else if containerLenS > len(v) {
		v = v[:containerLenS]
	}
	// for j := 0; j < containerLenS; j++ {
	for j := 0; ; j++ {
		if containerLenS >= 0 {
			if j >= containerLenS {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j >= len(v) {
			v = append(v, 0)
		}
		if j > 0 {
			slh.sep(j)
		}
		f.dd.initReadNext()
		v[j] = uint(f.dd.decodeUint(uintBitsize))

	}
	slh.end()
	if xaddr {
		*vp = v
	}
}

func (f *decFnInfo) fastDecSliceUint16(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp *[]uint16
	var v []uint16
	if xaddr {
		vp = rv.Addr().Interface().(*[]uint16)
		v = *vp
	} else {
		v = rv.Interface().([]uint16)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing.
		return
	}

	slh := decSliceHelper{dd: f.dd}
	containerLenS := slh.start()
	if containerLenS == 0 {
		if v == nil {
			v = []uint16{}
		} else {
			v = v[:0]
		}
		*vp = v
		f.dd.readArrayEnd()
		return
	}
	if v == nil {
		if containerLenS > 0 {
			v = make([]uint16, containerLenS, containerLenS)
		} else {
			v = make([]uint16, 0, 4)
		}
	} else if containerLenS > cap(v) {
		if f.array {
			decErr(msgDecCannotExpandArr, cap(v), containerLenS)
		}
		s := make([]uint16, containerLenS, containerLenS)
		copy(s, v)
		v = s
	} else if containerLenS > len(v) {
		v = v[:containerLenS]
	}
	// for j := 0; j < containerLenS; j++ {
	for j := 0; ; j++ {
		if containerLenS >= 0 {
			if j >= containerLenS {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j >= len(v) {
			v = append(v, 0)
		}
		if j > 0 {
			slh.sep(j)
		}
		f.dd.initReadNext()
		v[j] = uint16(f.dd.decodeUint(16))

	}
	slh.end()
	if xaddr {
		*vp = v
	}
}

func (f *decFnInfo) fastDecSliceUint32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp *[]uint32
	var v []uint32
	if xaddr {
		vp = rv.Addr().Interface().(*[]uint32)
		v = *vp
	} else {
		v = rv.Interface().([]uint32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing.
		return
	}

	slh := decSliceHelper{dd: f.dd}
	containerLenS := slh.start()
	if containerLenS == 0 {
		if v == nil {
			v = []uint32{}
		} else {
			v = v[:0]
		}
		*vp = v
		f.dd.readArrayEnd()
		return
	}
	if v == nil {
		if containerLenS > 0 {
			v = make([]uint32, containerLenS, containerLenS)
		} else {
			v = make([]uint32, 0, 4)
		}
	} else if containerLenS > cap(v) {
		if f.array {
			decErr(msgDecCannotExpandArr, cap(v), containerLenS)
		}
		s := make([]uint32, containerLenS, containerLenS)
		copy(s, v)
		v = s
	} else if containerLenS > len(v) {
		v = v[:containerLenS]
	}
	// for j := 0; j < containerLenS; j++ {
	for j := 0; ; j++ {
		if containerLenS >= 0 {
			if j >= containerLenS {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j >= len(v) {
			v = append(v, 0)
		}
		if j > 0 {
			slh.sep(j)
		}
		f.dd.initReadNext()
		v[j] = uint32(f.dd.decodeUint(32))

	}
	slh.end()
	if xaddr {
		*vp = v
	}
}

func (f *decFnInfo) fastDecSliceUint64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp *[]uint64
	var v []uint64
	if xaddr {
		vp = rv.Addr().Interface().(*[]uint64)
		v = *vp
	} else {
		v = rv.Interface().([]uint64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing.
		return
	}

	slh := decSliceHelper{dd: f.dd}
	containerLenS := slh.start()
	if containerLenS == 0 {
		if v == nil {
			v = []uint64{}
		} else {
			v = v[:0]
		}
		*vp = v
		f.dd.readArrayEnd()
		return
	}
	if v == nil {
		if containerLenS > 0 {
			v = make([]uint64, containerLenS, containerLenS)
		} else {
			v = make([]uint64, 0, 4)
		}
	} else if containerLenS > cap(v) {
		if f.array {
			decErr(msgDecCannotExpandArr, cap(v), containerLenS)
		}
		s := make([]uint64, containerLenS, containerLenS)
		copy(s, v)
		v = s
	} else if containerLenS > len(v) {
		v = v[:containerLenS]
	}
	// for j := 0; j < containerLenS; j++ {
	for j := 0; ; j++ {
		if containerLenS >= 0 {
			if j >= containerLenS {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j >= len(v) {
			v = append(v, 0)
		}
		if j > 0 {
			slh.sep(j)
		}
		f.dd.initReadNext()
		v[j] = f.dd.decodeUint(64)

	}
	slh.end()
	if xaddr {
		*vp = v
	}
}

func (f *decFnInfo) fastDecSliceInt(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp *[]int
	var v []int
	if xaddr {
		vp = rv.Addr().Interface().(*[]int)
		v = *vp
	} else {
		v = rv.Interface().([]int)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing.
		return
	}

	slh := decSliceHelper{dd: f.dd}
	containerLenS := slh.start()
	if containerLenS == 0 {
		if v == nil {
			v = []int{}
		} else {
			v = v[:0]
		}
		*vp = v
		f.dd.readArrayEnd()
		return
	}
	if v == nil {
		if containerLenS > 0 {
			v = make([]int, containerLenS, containerLenS)
		} else {
			v = make([]int, 0, 4)
		}
	} else if containerLenS > cap(v) {
		if f.array {
			decErr(msgDecCannotExpandArr, cap(v), containerLenS)
		}
		s := make([]int, containerLenS, containerLenS)
		copy(s, v)
		v = s
	} else if containerLenS > len(v) {
		v = v[:containerLenS]
	}
	// for j := 0; j < containerLenS; j++ {
	for j := 0; ; j++ {
		if containerLenS >= 0 {
			if j >= containerLenS {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j >= len(v) {
			v = append(v, 0)
		}
		if j > 0 {
			slh.sep(j)
		}
		f.dd.initReadNext()
		v[j] = int(f.dd.decodeInt(intBitsize))

	}
	slh.end()
	if xaddr {
		*vp = v
	}
}

func (f *decFnInfo) fastDecSliceInt8(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp *[]int8
	var v []int8
	if xaddr {
		vp = rv.Addr().Interface().(*[]int8)
		v = *vp
	} else {
		v = rv.Interface().([]int8)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing.
		return
	}

	slh := decSliceHelper{dd: f.dd}
	containerLenS := slh.start()
	if containerLenS == 0 {
		if v == nil {
			v = []int8{}
		} else {
			v = v[:0]
		}
		*vp = v
		f.dd.readArrayEnd()
		return
	}
	if v == nil {
		if containerLenS > 0 {
			v = make([]int8, containerLenS, containerLenS)
		} else {
			v = make([]int8, 0, 4)
		}
	} else if containerLenS > cap(v) {
		if f.array {
			decErr(msgDecCannotExpandArr, cap(v), containerLenS)
		}
		s := make([]int8, containerLenS, containerLenS)
		copy(s, v)
		v = s
	} else if containerLenS > len(v) {
		v = v[:containerLenS]
	}
	// for j := 0; j < containerLenS; j++ {
	for j := 0; ; j++ {
		if containerLenS >= 0 {
			if j >= containerLenS {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j >= len(v) {
			v = append(v, 0)
		}
		if j > 0 {
			slh.sep(j)
		}
		f.dd.initReadNext()
		v[j] = int8(f.dd.decodeInt(8))

	}
	slh.end()
	if xaddr {
		*vp = v
	}
}

func (f *decFnInfo) fastDecSliceInt16(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp *[]int16
	var v []int16
	if xaddr {
		vp = rv.Addr().Interface().(*[]int16)
		v = *vp
	} else {
		v = rv.Interface().([]int16)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing.
		return
	}

	slh := decSliceHelper{dd: f.dd}
	containerLenS := slh.start()
	if containerLenS == 0 {
		if v == nil {
			v = []int16{}
		} else {
			v = v[:0]
		}
		*vp = v
		f.dd.readArrayEnd()
		return
	}
	if v == nil {
		if containerLenS > 0 {
			v = make([]int16, containerLenS, containerLenS)
		} else {
			v = make([]int16, 0, 4)
		}
	} else if containerLenS > cap(v) {
		if f.array {
			decErr(msgDecCannotExpandArr, cap(v), containerLenS)
		}
		s := make([]int16, containerLenS, containerLenS)
		copy(s, v)
		v = s
	} else if containerLenS > len(v) {
		v = v[:containerLenS]
	}
	// for j := 0; j < containerLenS; j++ {
	for j := 0; ; j++ {
		if containerLenS >= 0 {
			if j >= containerLenS {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j >= len(v) {
			v = append(v, 0)
		}
		if j > 0 {
			slh.sep(j)
		}
		f.dd.initReadNext()
		v[j] = int16(f.dd.decodeInt(16))

	}
	slh.end()
	if xaddr {
		*vp = v
	}
}

func (f *decFnInfo) fastDecSliceInt32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp *[]int32
	var v []int32
	if xaddr {
		vp = rv.Addr().Interface().(*[]int32)
		v = *vp
	} else {
		v = rv.Interface().([]int32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing.
		return
	}

	slh := decSliceHelper{dd: f.dd}
	containerLenS := slh.start()
	if containerLenS == 0 {
		if v == nil {
			v = []int32{}
		} else {
			v = v[:0]
		}
		*vp = v
		f.dd.readArrayEnd()
		return
	}
	if v == nil {
		if containerLenS > 0 {
			v = make([]int32, containerLenS, containerLenS)
		} else {
			v = make([]int32, 0, 4)
		}
	} else if containerLenS > cap(v) {
		if f.array {
			decErr(msgDecCannotExpandArr, cap(v), containerLenS)
		}
		s := make([]int32, containerLenS, containerLenS)
		copy(s, v)
		v = s
	} else if containerLenS > len(v) {
		v = v[:containerLenS]
	}
	// for j := 0; j < containerLenS; j++ {
	for j := 0; ; j++ {
		if containerLenS >= 0 {
			if j >= containerLenS {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j >= len(v) {
			v = append(v, 0)
		}
		if j > 0 {
			slh.sep(j)
		}
		f.dd.initReadNext()
		v[j] = int32(f.dd.decodeInt(32))

	}
	slh.end()
	if xaddr {
		*vp = v
	}
}

func (f *decFnInfo) fastDecSliceInt64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp *[]int64
	var v []int64
	if xaddr {
		vp = rv.Addr().Interface().(*[]int64)
		v = *vp
	} else {
		v = rv.Interface().([]int64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing.
		return
	}

	slh := decSliceHelper{dd: f.dd}
	containerLenS := slh.start()
	if containerLenS == 0 {
		if v == nil {
			v = []int64{}
		} else {
			v = v[:0]
		}
		*vp = v
		f.dd.readArrayEnd()
		return
	}
	if v == nil {
		if containerLenS > 0 {
			v = make([]int64, containerLenS, containerLenS)
		} else {
			v = make([]int64, 0, 4)
		}
	} else if containerLenS > cap(v) {
		if f.array {
			decErr(msgDecCannotExpandArr, cap(v), containerLenS)
		}
		s := make([]int64, containerLenS, containerLenS)
		copy(s, v)
		v = s
	} else if containerLenS > len(v) {
		v = v[:containerLenS]
	}
	// for j := 0; j < containerLenS; j++ {
	for j := 0; ; j++ {
		if containerLenS >= 0 {
			if j >= containerLenS {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j >= len(v) {
			v = append(v, 0)
		}
		if j > 0 {
			slh.sep(j)
		}
		f.dd.initReadNext()
		v[j] = f.dd.decodeInt(64)

	}
	slh.end()
	if xaddr {
		*vp = v
	}
}

func (f *decFnInfo) fastDecSliceBool(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp *[]bool
	var v []bool
	if xaddr {
		vp = rv.Addr().Interface().(*[]bool)
		v = *vp
	} else {
		v = rv.Interface().([]bool)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing.
		return
	}

	slh := decSliceHelper{dd: f.dd}
	containerLenS := slh.start()
	if containerLenS == 0 {
		if v == nil {
			v = []bool{}
		} else {
			v = v[:0]
		}
		*vp = v
		f.dd.readArrayEnd()
		return
	}
	if v == nil {
		if containerLenS > 0 {
			v = make([]bool, containerLenS, containerLenS)
		} else {
			v = make([]bool, 0, 4)
		}
	} else if containerLenS > cap(v) {
		if f.array {
			decErr(msgDecCannotExpandArr, cap(v), containerLenS)
		}
		s := make([]bool, containerLenS, containerLenS)
		copy(s, v)
		v = s
	} else if containerLenS > len(v) {
		v = v[:containerLenS]
	}
	// for j := 0; j < containerLenS; j++ {
	for j := 0; ; j++ {
		if containerLenS >= 0 {
			if j >= containerLenS {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j >= len(v) {
			v = append(v, false)
		}
		if j > 0 {
			slh.sep(j)
		}
		f.dd.initReadNext()
		v[j] = f.dd.decodeBool()

	}
	slh.end()
	if xaddr {
		*vp = v
	}
}

func (f *decFnInfo) fastDecMapIntfIntf(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[interface{}]interface{})
	var v map[interface{}]interface{}
	if xaddr {
		vp = rv.Addr().Interface().(*map[interface{}]interface{})
		v = *vp
	} else {
		v = rv.Interface().(map[interface{}]interface{})
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[interface{}]interface{}{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[interface{}]interface{}, containerLen)
		} else {
			v = make(map[interface{}]interface{}) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		var mk interface{}
		f.d.decode(&mk)
		// special case if a byte array.
		if bv, bok := mk.([]byte); bok {
			mk = string(bv)
		}

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.d.decode(&mv)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapIntfString(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[interface{}]string)
	var v map[interface{}]string
	if xaddr {
		vp = rv.Addr().Interface().(*map[interface{}]string)
		v = *vp
	} else {
		v = rv.Interface().(map[interface{}]string)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[interface{}]string{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[interface{}]string, containerLen)
		} else {
			v = make(map[interface{}]string) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		var mk interface{}
		f.d.decode(&mk)
		// special case if a byte array.
		if bv, bok := mk.([]byte); bok {
			mk = string(bv)
		}

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeString()

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapIntfUint(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[interface{}]uint)
	var v map[interface{}]uint
	if xaddr {
		vp = rv.Addr().Interface().(*map[interface{}]uint)
		v = *vp
	} else {
		v = rv.Interface().(map[interface{}]uint)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[interface{}]uint{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[interface{}]uint, containerLen)
		} else {
			v = make(map[interface{}]uint) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		var mk interface{}
		f.d.decode(&mk)
		// special case if a byte array.
		if bv, bok := mk.([]byte); bok {
			mk = string(bv)
		}

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint(f.dd.decodeUint(uintBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapIntfUint32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[interface{}]uint32)
	var v map[interface{}]uint32
	if xaddr {
		vp = rv.Addr().Interface().(*map[interface{}]uint32)
		v = *vp
	} else {
		v = rv.Interface().(map[interface{}]uint32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[interface{}]uint32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[interface{}]uint32, containerLen)
		} else {
			v = make(map[interface{}]uint32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		var mk interface{}
		f.d.decode(&mk)
		// special case if a byte array.
		if bv, bok := mk.([]byte); bok {
			mk = string(bv)
		}

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint32(f.dd.decodeUint(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapIntfUint64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[interface{}]uint64)
	var v map[interface{}]uint64
	if xaddr {
		vp = rv.Addr().Interface().(*map[interface{}]uint64)
		v = *vp
	} else {
		v = rv.Interface().(map[interface{}]uint64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[interface{}]uint64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[interface{}]uint64, containerLen)
		} else {
			v = make(map[interface{}]uint64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		var mk interface{}
		f.d.decode(&mk)
		// special case if a byte array.
		if bv, bok := mk.([]byte); bok {
			mk = string(bv)
		}

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeUint(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapIntfInt(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[interface{}]int)
	var v map[interface{}]int
	if xaddr {
		vp = rv.Addr().Interface().(*map[interface{}]int)
		v = *vp
	} else {
		v = rv.Interface().(map[interface{}]int)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[interface{}]int{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[interface{}]int, containerLen)
		} else {
			v = make(map[interface{}]int) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		var mk interface{}
		f.d.decode(&mk)
		// special case if a byte array.
		if bv, bok := mk.([]byte); bok {
			mk = string(bv)
		}

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int(f.dd.decodeInt(intBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapIntfInt32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[interface{}]int32)
	var v map[interface{}]int32
	if xaddr {
		vp = rv.Addr().Interface().(*map[interface{}]int32)
		v = *vp
	} else {
		v = rv.Interface().(map[interface{}]int32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[interface{}]int32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[interface{}]int32, containerLen)
		} else {
			v = make(map[interface{}]int32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		var mk interface{}
		f.d.decode(&mk)
		// special case if a byte array.
		if bv, bok := mk.([]byte); bok {
			mk = string(bv)
		}

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int32(f.dd.decodeInt(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapIntfInt64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[interface{}]int64)
	var v map[interface{}]int64
	if xaddr {
		vp = rv.Addr().Interface().(*map[interface{}]int64)
		v = *vp
	} else {
		v = rv.Interface().(map[interface{}]int64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[interface{}]int64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[interface{}]int64, containerLen)
		} else {
			v = make(map[interface{}]int64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		var mk interface{}
		f.d.decode(&mk)
		// special case if a byte array.
		if bv, bok := mk.([]byte); bok {
			mk = string(bv)
		}

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeInt(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapStringIntf(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[string]interface{})
	var v map[string]interface{}
	if xaddr {
		vp = rv.Addr().Interface().(*map[string]interface{})
		v = *vp
	} else {
		v = rv.Interface().(map[string]interface{})
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[string]interface{}{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[string]interface{}, containerLen)
		} else {
			v = make(map[string]interface{}) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeString()

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.d.decode(&mv)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapStringString(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[string]string)
	var v map[string]string
	if xaddr {
		vp = rv.Addr().Interface().(*map[string]string)
		v = *vp
	} else {
		v = rv.Interface().(map[string]string)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[string]string{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[string]string, containerLen)
		} else {
			v = make(map[string]string) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeString()

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeString()

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapStringUint(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[string]uint)
	var v map[string]uint
	if xaddr {
		vp = rv.Addr().Interface().(*map[string]uint)
		v = *vp
	} else {
		v = rv.Interface().(map[string]uint)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[string]uint{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[string]uint, containerLen)
		} else {
			v = make(map[string]uint) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeString()

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint(f.dd.decodeUint(uintBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapStringUint32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[string]uint32)
	var v map[string]uint32
	if xaddr {
		vp = rv.Addr().Interface().(*map[string]uint32)
		v = *vp
	} else {
		v = rv.Interface().(map[string]uint32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[string]uint32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[string]uint32, containerLen)
		} else {
			v = make(map[string]uint32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeString()

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint32(f.dd.decodeUint(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapStringUint64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[string]uint64)
	var v map[string]uint64
	if xaddr {
		vp = rv.Addr().Interface().(*map[string]uint64)
		v = *vp
	} else {
		v = rv.Interface().(map[string]uint64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[string]uint64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[string]uint64, containerLen)
		} else {
			v = make(map[string]uint64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeString()

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeUint(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapStringInt(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[string]int)
	var v map[string]int
	if xaddr {
		vp = rv.Addr().Interface().(*map[string]int)
		v = *vp
	} else {
		v = rv.Interface().(map[string]int)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[string]int{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[string]int, containerLen)
		} else {
			v = make(map[string]int) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeString()

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int(f.dd.decodeInt(intBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapStringInt32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[string]int32)
	var v map[string]int32
	if xaddr {
		vp = rv.Addr().Interface().(*map[string]int32)
		v = *vp
	} else {
		v = rv.Interface().(map[string]int32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[string]int32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[string]int32, containerLen)
		} else {
			v = make(map[string]int32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeString()

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int32(f.dd.decodeInt(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapStringInt64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[string]int64)
	var v map[string]int64
	if xaddr {
		vp = rv.Addr().Interface().(*map[string]int64)
		v = *vp
	} else {
		v = rv.Interface().(map[string]int64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[string]int64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[string]int64, containerLen)
		} else {
			v = make(map[string]int64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeString()

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeInt(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapFloat32Float32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[float32]float32)
	var v map[float32]float32
	if xaddr {
		vp = rv.Addr().Interface().(*map[float32]float32)
		v = *vp
	} else {
		v = rv.Interface().(map[float32]float32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[float32]float32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[float32]float32, containerLen)
		} else {
			v = make(map[float32]float32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := float32(f.dd.decodeFloat(true))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = float32(f.dd.decodeFloat(true))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapFloat32Intf(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[float32]interface{})
	var v map[float32]interface{}
	if xaddr {
		vp = rv.Addr().Interface().(*map[float32]interface{})
		v = *vp
	} else {
		v = rv.Interface().(map[float32]interface{})
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[float32]interface{}{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[float32]interface{}, containerLen)
		} else {
			v = make(map[float32]interface{}) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := float32(f.dd.decodeFloat(true))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.d.decode(&mv)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapFloat32String(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[float32]string)
	var v map[float32]string
	if xaddr {
		vp = rv.Addr().Interface().(*map[float32]string)
		v = *vp
	} else {
		v = rv.Interface().(map[float32]string)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[float32]string{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[float32]string, containerLen)
		} else {
			v = make(map[float32]string) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := float32(f.dd.decodeFloat(true))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeString()

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapFloat32Uint(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[float32]uint)
	var v map[float32]uint
	if xaddr {
		vp = rv.Addr().Interface().(*map[float32]uint)
		v = *vp
	} else {
		v = rv.Interface().(map[float32]uint)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[float32]uint{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[float32]uint, containerLen)
		} else {
			v = make(map[float32]uint) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := float32(f.dd.decodeFloat(true))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint(f.dd.decodeUint(uintBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapFloat32Uint32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[float32]uint32)
	var v map[float32]uint32
	if xaddr {
		vp = rv.Addr().Interface().(*map[float32]uint32)
		v = *vp
	} else {
		v = rv.Interface().(map[float32]uint32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[float32]uint32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[float32]uint32, containerLen)
		} else {
			v = make(map[float32]uint32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := float32(f.dd.decodeFloat(true))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint32(f.dd.decodeUint(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapFloat32Uint64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[float32]uint64)
	var v map[float32]uint64
	if xaddr {
		vp = rv.Addr().Interface().(*map[float32]uint64)
		v = *vp
	} else {
		v = rv.Interface().(map[float32]uint64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[float32]uint64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[float32]uint64, containerLen)
		} else {
			v = make(map[float32]uint64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := float32(f.dd.decodeFloat(true))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeUint(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapFloat32Int(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[float32]int)
	var v map[float32]int
	if xaddr {
		vp = rv.Addr().Interface().(*map[float32]int)
		v = *vp
	} else {
		v = rv.Interface().(map[float32]int)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[float32]int{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[float32]int, containerLen)
		} else {
			v = make(map[float32]int) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := float32(f.dd.decodeFloat(true))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int(f.dd.decodeInt(intBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapFloat32Int32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[float32]int32)
	var v map[float32]int32
	if xaddr {
		vp = rv.Addr().Interface().(*map[float32]int32)
		v = *vp
	} else {
		v = rv.Interface().(map[float32]int32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[float32]int32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[float32]int32, containerLen)
		} else {
			v = make(map[float32]int32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := float32(f.dd.decodeFloat(true))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int32(f.dd.decodeInt(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapFloat32Int64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[float32]int64)
	var v map[float32]int64
	if xaddr {
		vp = rv.Addr().Interface().(*map[float32]int64)
		v = *vp
	} else {
		v = rv.Interface().(map[float32]int64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[float32]int64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[float32]int64, containerLen)
		} else {
			v = make(map[float32]int64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := float32(f.dd.decodeFloat(true))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeInt(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapFloat64Float64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[float64]float64)
	var v map[float64]float64
	if xaddr {
		vp = rv.Addr().Interface().(*map[float64]float64)
		v = *vp
	} else {
		v = rv.Interface().(map[float64]float64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[float64]float64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[float64]float64, containerLen)
		} else {
			v = make(map[float64]float64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeFloat(false)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeFloat(false)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapFloat64Intf(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[float64]interface{})
	var v map[float64]interface{}
	if xaddr {
		vp = rv.Addr().Interface().(*map[float64]interface{})
		v = *vp
	} else {
		v = rv.Interface().(map[float64]interface{})
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[float64]interface{}{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[float64]interface{}, containerLen)
		} else {
			v = make(map[float64]interface{}) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeFloat(false)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.d.decode(&mv)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapFloat64String(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[float64]string)
	var v map[float64]string
	if xaddr {
		vp = rv.Addr().Interface().(*map[float64]string)
		v = *vp
	} else {
		v = rv.Interface().(map[float64]string)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[float64]string{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[float64]string, containerLen)
		} else {
			v = make(map[float64]string) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeFloat(false)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeString()

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapFloat64Uint(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[float64]uint)
	var v map[float64]uint
	if xaddr {
		vp = rv.Addr().Interface().(*map[float64]uint)
		v = *vp
	} else {
		v = rv.Interface().(map[float64]uint)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[float64]uint{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[float64]uint, containerLen)
		} else {
			v = make(map[float64]uint) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeFloat(false)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint(f.dd.decodeUint(uintBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapFloat64Uint32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[float64]uint32)
	var v map[float64]uint32
	if xaddr {
		vp = rv.Addr().Interface().(*map[float64]uint32)
		v = *vp
	} else {
		v = rv.Interface().(map[float64]uint32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[float64]uint32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[float64]uint32, containerLen)
		} else {
			v = make(map[float64]uint32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeFloat(false)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint32(f.dd.decodeUint(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapFloat64Uint64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[float64]uint64)
	var v map[float64]uint64
	if xaddr {
		vp = rv.Addr().Interface().(*map[float64]uint64)
		v = *vp
	} else {
		v = rv.Interface().(map[float64]uint64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[float64]uint64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[float64]uint64, containerLen)
		} else {
			v = make(map[float64]uint64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeFloat(false)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeUint(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapFloat64Int(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[float64]int)
	var v map[float64]int
	if xaddr {
		vp = rv.Addr().Interface().(*map[float64]int)
		v = *vp
	} else {
		v = rv.Interface().(map[float64]int)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[float64]int{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[float64]int, containerLen)
		} else {
			v = make(map[float64]int) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeFloat(false)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int(f.dd.decodeInt(intBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapFloat64Int32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[float64]int32)
	var v map[float64]int32
	if xaddr {
		vp = rv.Addr().Interface().(*map[float64]int32)
		v = *vp
	} else {
		v = rv.Interface().(map[float64]int32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[float64]int32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[float64]int32, containerLen)
		} else {
			v = make(map[float64]int32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeFloat(false)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int32(f.dd.decodeInt(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapFloat64Int64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[float64]int64)
	var v map[float64]int64
	if xaddr {
		vp = rv.Addr().Interface().(*map[float64]int64)
		v = *vp
	} else {
		v = rv.Interface().(map[float64]int64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[float64]int64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[float64]int64, containerLen)
		} else {
			v = make(map[float64]int64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeFloat(false)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeInt(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUintIntf(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint]interface{})
	var v map[uint]interface{}
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint]interface{})
		v = *vp
	} else {
		v = rv.Interface().(map[uint]interface{})
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint]interface{}{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint]interface{}, containerLen)
		} else {
			v = make(map[uint]interface{}) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint(f.dd.decodeUint(uintBitsize))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.d.decode(&mv)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUintString(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint]string)
	var v map[uint]string
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint]string)
		v = *vp
	} else {
		v = rv.Interface().(map[uint]string)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint]string{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint]string, containerLen)
		} else {
			v = make(map[uint]string) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint(f.dd.decodeUint(uintBitsize))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeString()

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUintUint(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint]uint)
	var v map[uint]uint
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint]uint)
		v = *vp
	} else {
		v = rv.Interface().(map[uint]uint)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint]uint{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint]uint, containerLen)
		} else {
			v = make(map[uint]uint) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint(f.dd.decodeUint(uintBitsize))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint(f.dd.decodeUint(uintBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUintUint32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint]uint32)
	var v map[uint]uint32
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint]uint32)
		v = *vp
	} else {
		v = rv.Interface().(map[uint]uint32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint]uint32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint]uint32, containerLen)
		} else {
			v = make(map[uint]uint32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint(f.dd.decodeUint(uintBitsize))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint32(f.dd.decodeUint(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUintUint64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint]uint64)
	var v map[uint]uint64
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint]uint64)
		v = *vp
	} else {
		v = rv.Interface().(map[uint]uint64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint]uint64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint]uint64, containerLen)
		} else {
			v = make(map[uint]uint64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint(f.dd.decodeUint(uintBitsize))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeUint(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUintInt(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint]int)
	var v map[uint]int
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint]int)
		v = *vp
	} else {
		v = rv.Interface().(map[uint]int)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint]int{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint]int, containerLen)
		} else {
			v = make(map[uint]int) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint(f.dd.decodeUint(uintBitsize))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int(f.dd.decodeInt(intBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUintInt32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint]int32)
	var v map[uint]int32
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint]int32)
		v = *vp
	} else {
		v = rv.Interface().(map[uint]int32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint]int32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint]int32, containerLen)
		} else {
			v = make(map[uint]int32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint(f.dd.decodeUint(uintBitsize))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int32(f.dd.decodeInt(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUintInt64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint]int64)
	var v map[uint]int64
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint]int64)
		v = *vp
	} else {
		v = rv.Interface().(map[uint]int64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint]int64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint]int64, containerLen)
		} else {
			v = make(map[uint]int64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint(f.dd.decodeUint(uintBitsize))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeInt(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint8Uint8(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint8]uint8)
	var v map[uint8]uint8
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint8]uint8)
		v = *vp
	} else {
		v = rv.Interface().(map[uint8]uint8)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint8]uint8{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint8]uint8, containerLen)
		} else {
			v = make(map[uint8]uint8) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint8(f.dd.decodeUint(8))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint8(f.dd.decodeUint(8))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint8Intf(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint8]interface{})
	var v map[uint8]interface{}
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint8]interface{})
		v = *vp
	} else {
		v = rv.Interface().(map[uint8]interface{})
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint8]interface{}{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint8]interface{}, containerLen)
		} else {
			v = make(map[uint8]interface{}) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint8(f.dd.decodeUint(8))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.d.decode(&mv)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint8String(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint8]string)
	var v map[uint8]string
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint8]string)
		v = *vp
	} else {
		v = rv.Interface().(map[uint8]string)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint8]string{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint8]string, containerLen)
		} else {
			v = make(map[uint8]string) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint8(f.dd.decodeUint(8))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeString()

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint8Uint(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint8]uint)
	var v map[uint8]uint
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint8]uint)
		v = *vp
	} else {
		v = rv.Interface().(map[uint8]uint)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint8]uint{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint8]uint, containerLen)
		} else {
			v = make(map[uint8]uint) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint8(f.dd.decodeUint(8))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint(f.dd.decodeUint(uintBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint8Uint32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint8]uint32)
	var v map[uint8]uint32
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint8]uint32)
		v = *vp
	} else {
		v = rv.Interface().(map[uint8]uint32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint8]uint32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint8]uint32, containerLen)
		} else {
			v = make(map[uint8]uint32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint8(f.dd.decodeUint(8))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint32(f.dd.decodeUint(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint8Uint64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint8]uint64)
	var v map[uint8]uint64
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint8]uint64)
		v = *vp
	} else {
		v = rv.Interface().(map[uint8]uint64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint8]uint64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint8]uint64, containerLen)
		} else {
			v = make(map[uint8]uint64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint8(f.dd.decodeUint(8))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeUint(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint8Int(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint8]int)
	var v map[uint8]int
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint8]int)
		v = *vp
	} else {
		v = rv.Interface().(map[uint8]int)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint8]int{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint8]int, containerLen)
		} else {
			v = make(map[uint8]int) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint8(f.dd.decodeUint(8))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int(f.dd.decodeInt(intBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint8Int32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint8]int32)
	var v map[uint8]int32
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint8]int32)
		v = *vp
	} else {
		v = rv.Interface().(map[uint8]int32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint8]int32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint8]int32, containerLen)
		} else {
			v = make(map[uint8]int32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint8(f.dd.decodeUint(8))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int32(f.dd.decodeInt(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint8Int64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint8]int64)
	var v map[uint8]int64
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint8]int64)
		v = *vp
	} else {
		v = rv.Interface().(map[uint8]int64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint8]int64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint8]int64, containerLen)
		} else {
			v = make(map[uint8]int64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint8(f.dd.decodeUint(8))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeInt(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint16Uint16(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint16]uint16)
	var v map[uint16]uint16
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint16]uint16)
		v = *vp
	} else {
		v = rv.Interface().(map[uint16]uint16)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint16]uint16{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint16]uint16, containerLen)
		} else {
			v = make(map[uint16]uint16) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint16(f.dd.decodeUint(16))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint16(f.dd.decodeUint(16))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint16Intf(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint16]interface{})
	var v map[uint16]interface{}
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint16]interface{})
		v = *vp
	} else {
		v = rv.Interface().(map[uint16]interface{})
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint16]interface{}{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint16]interface{}, containerLen)
		} else {
			v = make(map[uint16]interface{}) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint16(f.dd.decodeUint(16))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.d.decode(&mv)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint16String(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint16]string)
	var v map[uint16]string
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint16]string)
		v = *vp
	} else {
		v = rv.Interface().(map[uint16]string)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint16]string{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint16]string, containerLen)
		} else {
			v = make(map[uint16]string) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint16(f.dd.decodeUint(16))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeString()

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint16Uint(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint16]uint)
	var v map[uint16]uint
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint16]uint)
		v = *vp
	} else {
		v = rv.Interface().(map[uint16]uint)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint16]uint{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint16]uint, containerLen)
		} else {
			v = make(map[uint16]uint) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint16(f.dd.decodeUint(16))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint(f.dd.decodeUint(uintBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint16Uint32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint16]uint32)
	var v map[uint16]uint32
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint16]uint32)
		v = *vp
	} else {
		v = rv.Interface().(map[uint16]uint32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint16]uint32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint16]uint32, containerLen)
		} else {
			v = make(map[uint16]uint32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint16(f.dd.decodeUint(16))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint32(f.dd.decodeUint(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint16Uint64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint16]uint64)
	var v map[uint16]uint64
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint16]uint64)
		v = *vp
	} else {
		v = rv.Interface().(map[uint16]uint64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint16]uint64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint16]uint64, containerLen)
		} else {
			v = make(map[uint16]uint64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint16(f.dd.decodeUint(16))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeUint(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint16Int(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint16]int)
	var v map[uint16]int
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint16]int)
		v = *vp
	} else {
		v = rv.Interface().(map[uint16]int)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint16]int{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint16]int, containerLen)
		} else {
			v = make(map[uint16]int) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint16(f.dd.decodeUint(16))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int(f.dd.decodeInt(intBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint16Int32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint16]int32)
	var v map[uint16]int32
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint16]int32)
		v = *vp
	} else {
		v = rv.Interface().(map[uint16]int32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint16]int32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint16]int32, containerLen)
		} else {
			v = make(map[uint16]int32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint16(f.dd.decodeUint(16))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int32(f.dd.decodeInt(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint16Int64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint16]int64)
	var v map[uint16]int64
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint16]int64)
		v = *vp
	} else {
		v = rv.Interface().(map[uint16]int64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint16]int64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint16]int64, containerLen)
		} else {
			v = make(map[uint16]int64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint16(f.dd.decodeUint(16))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeInt(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint32Intf(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint32]interface{})
	var v map[uint32]interface{}
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint32]interface{})
		v = *vp
	} else {
		v = rv.Interface().(map[uint32]interface{})
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint32]interface{}{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint32]interface{}, containerLen)
		} else {
			v = make(map[uint32]interface{}) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint32(f.dd.decodeUint(32))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.d.decode(&mv)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint32String(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint32]string)
	var v map[uint32]string
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint32]string)
		v = *vp
	} else {
		v = rv.Interface().(map[uint32]string)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint32]string{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint32]string, containerLen)
		} else {
			v = make(map[uint32]string) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint32(f.dd.decodeUint(32))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeString()

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint32Uint(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint32]uint)
	var v map[uint32]uint
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint32]uint)
		v = *vp
	} else {
		v = rv.Interface().(map[uint32]uint)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint32]uint{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint32]uint, containerLen)
		} else {
			v = make(map[uint32]uint) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint32(f.dd.decodeUint(32))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint(f.dd.decodeUint(uintBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint32Uint32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint32]uint32)
	var v map[uint32]uint32
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint32]uint32)
		v = *vp
	} else {
		v = rv.Interface().(map[uint32]uint32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint32]uint32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint32]uint32, containerLen)
		} else {
			v = make(map[uint32]uint32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint32(f.dd.decodeUint(32))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint32(f.dd.decodeUint(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint32Uint64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint32]uint64)
	var v map[uint32]uint64
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint32]uint64)
		v = *vp
	} else {
		v = rv.Interface().(map[uint32]uint64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint32]uint64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint32]uint64, containerLen)
		} else {
			v = make(map[uint32]uint64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint32(f.dd.decodeUint(32))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeUint(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint32Int(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint32]int)
	var v map[uint32]int
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint32]int)
		v = *vp
	} else {
		v = rv.Interface().(map[uint32]int)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint32]int{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint32]int, containerLen)
		} else {
			v = make(map[uint32]int) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint32(f.dd.decodeUint(32))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int(f.dd.decodeInt(intBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint32Int32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint32]int32)
	var v map[uint32]int32
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint32]int32)
		v = *vp
	} else {
		v = rv.Interface().(map[uint32]int32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint32]int32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint32]int32, containerLen)
		} else {
			v = make(map[uint32]int32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint32(f.dd.decodeUint(32))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int32(f.dd.decodeInt(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint32Int64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint32]int64)
	var v map[uint32]int64
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint32]int64)
		v = *vp
	} else {
		v = rv.Interface().(map[uint32]int64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint32]int64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint32]int64, containerLen)
		} else {
			v = make(map[uint32]int64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := uint32(f.dd.decodeUint(32))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeInt(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint64Intf(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint64]interface{})
	var v map[uint64]interface{}
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint64]interface{})
		v = *vp
	} else {
		v = rv.Interface().(map[uint64]interface{})
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint64]interface{}{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint64]interface{}, containerLen)
		} else {
			v = make(map[uint64]interface{}) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeUint(64)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.d.decode(&mv)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint64String(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint64]string)
	var v map[uint64]string
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint64]string)
		v = *vp
	} else {
		v = rv.Interface().(map[uint64]string)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint64]string{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint64]string, containerLen)
		} else {
			v = make(map[uint64]string) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeUint(64)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeString()

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint64Uint(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint64]uint)
	var v map[uint64]uint
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint64]uint)
		v = *vp
	} else {
		v = rv.Interface().(map[uint64]uint)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint64]uint{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint64]uint, containerLen)
		} else {
			v = make(map[uint64]uint) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeUint(64)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint(f.dd.decodeUint(uintBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint64Uint32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint64]uint32)
	var v map[uint64]uint32
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint64]uint32)
		v = *vp
	} else {
		v = rv.Interface().(map[uint64]uint32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint64]uint32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint64]uint32, containerLen)
		} else {
			v = make(map[uint64]uint32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeUint(64)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint32(f.dd.decodeUint(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint64Uint64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint64]uint64)
	var v map[uint64]uint64
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint64]uint64)
		v = *vp
	} else {
		v = rv.Interface().(map[uint64]uint64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint64]uint64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint64]uint64, containerLen)
		} else {
			v = make(map[uint64]uint64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeUint(64)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeUint(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint64Int(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint64]int)
	var v map[uint64]int
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint64]int)
		v = *vp
	} else {
		v = rv.Interface().(map[uint64]int)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint64]int{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint64]int, containerLen)
		} else {
			v = make(map[uint64]int) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeUint(64)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int(f.dd.decodeInt(intBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint64Int32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint64]int32)
	var v map[uint64]int32
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint64]int32)
		v = *vp
	} else {
		v = rv.Interface().(map[uint64]int32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint64]int32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint64]int32, containerLen)
		} else {
			v = make(map[uint64]int32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeUint(64)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int32(f.dd.decodeInt(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapUint64Int64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[uint64]int64)
	var v map[uint64]int64
	if xaddr {
		vp = rv.Addr().Interface().(*map[uint64]int64)
		v = *vp
	} else {
		v = rv.Interface().(map[uint64]int64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[uint64]int64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[uint64]int64, containerLen)
		} else {
			v = make(map[uint64]int64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeUint(64)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeInt(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapIntIntf(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int]interface{})
	var v map[int]interface{}
	if xaddr {
		vp = rv.Addr().Interface().(*map[int]interface{})
		v = *vp
	} else {
		v = rv.Interface().(map[int]interface{})
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int]interface{}{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int]interface{}, containerLen)
		} else {
			v = make(map[int]interface{}) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int(f.dd.decodeInt(intBitsize))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.d.decode(&mv)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapIntString(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int]string)
	var v map[int]string
	if xaddr {
		vp = rv.Addr().Interface().(*map[int]string)
		v = *vp
	} else {
		v = rv.Interface().(map[int]string)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int]string{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int]string, containerLen)
		} else {
			v = make(map[int]string) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int(f.dd.decodeInt(intBitsize))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeString()

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapIntUint(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int]uint)
	var v map[int]uint
	if xaddr {
		vp = rv.Addr().Interface().(*map[int]uint)
		v = *vp
	} else {
		v = rv.Interface().(map[int]uint)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int]uint{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int]uint, containerLen)
		} else {
			v = make(map[int]uint) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int(f.dd.decodeInt(intBitsize))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint(f.dd.decodeUint(uintBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapIntUint32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int]uint32)
	var v map[int]uint32
	if xaddr {
		vp = rv.Addr().Interface().(*map[int]uint32)
		v = *vp
	} else {
		v = rv.Interface().(map[int]uint32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int]uint32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int]uint32, containerLen)
		} else {
			v = make(map[int]uint32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int(f.dd.decodeInt(intBitsize))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint32(f.dd.decodeUint(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapIntUint64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int]uint64)
	var v map[int]uint64
	if xaddr {
		vp = rv.Addr().Interface().(*map[int]uint64)
		v = *vp
	} else {
		v = rv.Interface().(map[int]uint64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int]uint64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int]uint64, containerLen)
		} else {
			v = make(map[int]uint64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int(f.dd.decodeInt(intBitsize))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeUint(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapIntInt(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int]int)
	var v map[int]int
	if xaddr {
		vp = rv.Addr().Interface().(*map[int]int)
		v = *vp
	} else {
		v = rv.Interface().(map[int]int)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int]int{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int]int, containerLen)
		} else {
			v = make(map[int]int) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int(f.dd.decodeInt(intBitsize))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int(f.dd.decodeInt(intBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapIntInt32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int]int32)
	var v map[int]int32
	if xaddr {
		vp = rv.Addr().Interface().(*map[int]int32)
		v = *vp
	} else {
		v = rv.Interface().(map[int]int32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int]int32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int]int32, containerLen)
		} else {
			v = make(map[int]int32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int(f.dd.decodeInt(intBitsize))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int32(f.dd.decodeInt(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapIntInt64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int]int64)
	var v map[int]int64
	if xaddr {
		vp = rv.Addr().Interface().(*map[int]int64)
		v = *vp
	} else {
		v = rv.Interface().(map[int]int64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int]int64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int]int64, containerLen)
		} else {
			v = make(map[int]int64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int(f.dd.decodeInt(intBitsize))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeInt(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt8Int8(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int8]int8)
	var v map[int8]int8
	if xaddr {
		vp = rv.Addr().Interface().(*map[int8]int8)
		v = *vp
	} else {
		v = rv.Interface().(map[int8]int8)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int8]int8{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int8]int8, containerLen)
		} else {
			v = make(map[int8]int8) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int8(f.dd.decodeInt(8))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int8(f.dd.decodeInt(8))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt8Intf(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int8]interface{})
	var v map[int8]interface{}
	if xaddr {
		vp = rv.Addr().Interface().(*map[int8]interface{})
		v = *vp
	} else {
		v = rv.Interface().(map[int8]interface{})
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int8]interface{}{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int8]interface{}, containerLen)
		} else {
			v = make(map[int8]interface{}) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int8(f.dd.decodeInt(8))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.d.decode(&mv)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt8String(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int8]string)
	var v map[int8]string
	if xaddr {
		vp = rv.Addr().Interface().(*map[int8]string)
		v = *vp
	} else {
		v = rv.Interface().(map[int8]string)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int8]string{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int8]string, containerLen)
		} else {
			v = make(map[int8]string) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int8(f.dd.decodeInt(8))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeString()

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt8Uint(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int8]uint)
	var v map[int8]uint
	if xaddr {
		vp = rv.Addr().Interface().(*map[int8]uint)
		v = *vp
	} else {
		v = rv.Interface().(map[int8]uint)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int8]uint{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int8]uint, containerLen)
		} else {
			v = make(map[int8]uint) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int8(f.dd.decodeInt(8))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint(f.dd.decodeUint(uintBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt8Uint32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int8]uint32)
	var v map[int8]uint32
	if xaddr {
		vp = rv.Addr().Interface().(*map[int8]uint32)
		v = *vp
	} else {
		v = rv.Interface().(map[int8]uint32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int8]uint32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int8]uint32, containerLen)
		} else {
			v = make(map[int8]uint32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int8(f.dd.decodeInt(8))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint32(f.dd.decodeUint(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt8Uint64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int8]uint64)
	var v map[int8]uint64
	if xaddr {
		vp = rv.Addr().Interface().(*map[int8]uint64)
		v = *vp
	} else {
		v = rv.Interface().(map[int8]uint64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int8]uint64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int8]uint64, containerLen)
		} else {
			v = make(map[int8]uint64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int8(f.dd.decodeInt(8))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeUint(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt8Int(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int8]int)
	var v map[int8]int
	if xaddr {
		vp = rv.Addr().Interface().(*map[int8]int)
		v = *vp
	} else {
		v = rv.Interface().(map[int8]int)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int8]int{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int8]int, containerLen)
		} else {
			v = make(map[int8]int) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int8(f.dd.decodeInt(8))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int(f.dd.decodeInt(intBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt8Int32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int8]int32)
	var v map[int8]int32
	if xaddr {
		vp = rv.Addr().Interface().(*map[int8]int32)
		v = *vp
	} else {
		v = rv.Interface().(map[int8]int32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int8]int32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int8]int32, containerLen)
		} else {
			v = make(map[int8]int32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int8(f.dd.decodeInt(8))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int32(f.dd.decodeInt(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt8Int64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int8]int64)
	var v map[int8]int64
	if xaddr {
		vp = rv.Addr().Interface().(*map[int8]int64)
		v = *vp
	} else {
		v = rv.Interface().(map[int8]int64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int8]int64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int8]int64, containerLen)
		} else {
			v = make(map[int8]int64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int8(f.dd.decodeInt(8))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeInt(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt16Int16(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int16]int16)
	var v map[int16]int16
	if xaddr {
		vp = rv.Addr().Interface().(*map[int16]int16)
		v = *vp
	} else {
		v = rv.Interface().(map[int16]int16)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int16]int16{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int16]int16, containerLen)
		} else {
			v = make(map[int16]int16) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int16(f.dd.decodeInt(16))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int16(f.dd.decodeInt(16))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt16Intf(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int16]interface{})
	var v map[int16]interface{}
	if xaddr {
		vp = rv.Addr().Interface().(*map[int16]interface{})
		v = *vp
	} else {
		v = rv.Interface().(map[int16]interface{})
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int16]interface{}{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int16]interface{}, containerLen)
		} else {
			v = make(map[int16]interface{}) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int16(f.dd.decodeInt(16))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.d.decode(&mv)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt16String(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int16]string)
	var v map[int16]string
	if xaddr {
		vp = rv.Addr().Interface().(*map[int16]string)
		v = *vp
	} else {
		v = rv.Interface().(map[int16]string)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int16]string{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int16]string, containerLen)
		} else {
			v = make(map[int16]string) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int16(f.dd.decodeInt(16))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeString()

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt16Uint(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int16]uint)
	var v map[int16]uint
	if xaddr {
		vp = rv.Addr().Interface().(*map[int16]uint)
		v = *vp
	} else {
		v = rv.Interface().(map[int16]uint)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int16]uint{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int16]uint, containerLen)
		} else {
			v = make(map[int16]uint) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int16(f.dd.decodeInt(16))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint(f.dd.decodeUint(uintBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt16Uint32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int16]uint32)
	var v map[int16]uint32
	if xaddr {
		vp = rv.Addr().Interface().(*map[int16]uint32)
		v = *vp
	} else {
		v = rv.Interface().(map[int16]uint32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int16]uint32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int16]uint32, containerLen)
		} else {
			v = make(map[int16]uint32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int16(f.dd.decodeInt(16))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint32(f.dd.decodeUint(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt16Uint64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int16]uint64)
	var v map[int16]uint64
	if xaddr {
		vp = rv.Addr().Interface().(*map[int16]uint64)
		v = *vp
	} else {
		v = rv.Interface().(map[int16]uint64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int16]uint64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int16]uint64, containerLen)
		} else {
			v = make(map[int16]uint64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int16(f.dd.decodeInt(16))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeUint(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt16Int(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int16]int)
	var v map[int16]int
	if xaddr {
		vp = rv.Addr().Interface().(*map[int16]int)
		v = *vp
	} else {
		v = rv.Interface().(map[int16]int)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int16]int{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int16]int, containerLen)
		} else {
			v = make(map[int16]int) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int16(f.dd.decodeInt(16))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int(f.dd.decodeInt(intBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt16Int32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int16]int32)
	var v map[int16]int32
	if xaddr {
		vp = rv.Addr().Interface().(*map[int16]int32)
		v = *vp
	} else {
		v = rv.Interface().(map[int16]int32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int16]int32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int16]int32, containerLen)
		} else {
			v = make(map[int16]int32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int16(f.dd.decodeInt(16))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int32(f.dd.decodeInt(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt16Int64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int16]int64)
	var v map[int16]int64
	if xaddr {
		vp = rv.Addr().Interface().(*map[int16]int64)
		v = *vp
	} else {
		v = rv.Interface().(map[int16]int64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int16]int64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int16]int64, containerLen)
		} else {
			v = make(map[int16]int64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int16(f.dd.decodeInt(16))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeInt(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt32Intf(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int32]interface{})
	var v map[int32]interface{}
	if xaddr {
		vp = rv.Addr().Interface().(*map[int32]interface{})
		v = *vp
	} else {
		v = rv.Interface().(map[int32]interface{})
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int32]interface{}{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int32]interface{}, containerLen)
		} else {
			v = make(map[int32]interface{}) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int32(f.dd.decodeInt(32))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.d.decode(&mv)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt32String(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int32]string)
	var v map[int32]string
	if xaddr {
		vp = rv.Addr().Interface().(*map[int32]string)
		v = *vp
	} else {
		v = rv.Interface().(map[int32]string)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int32]string{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int32]string, containerLen)
		} else {
			v = make(map[int32]string) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int32(f.dd.decodeInt(32))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeString()

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt32Uint(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int32]uint)
	var v map[int32]uint
	if xaddr {
		vp = rv.Addr().Interface().(*map[int32]uint)
		v = *vp
	} else {
		v = rv.Interface().(map[int32]uint)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int32]uint{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int32]uint, containerLen)
		} else {
			v = make(map[int32]uint) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int32(f.dd.decodeInt(32))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint(f.dd.decodeUint(uintBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt32Uint32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int32]uint32)
	var v map[int32]uint32
	if xaddr {
		vp = rv.Addr().Interface().(*map[int32]uint32)
		v = *vp
	} else {
		v = rv.Interface().(map[int32]uint32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int32]uint32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int32]uint32, containerLen)
		} else {
			v = make(map[int32]uint32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int32(f.dd.decodeInt(32))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint32(f.dd.decodeUint(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt32Uint64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int32]uint64)
	var v map[int32]uint64
	if xaddr {
		vp = rv.Addr().Interface().(*map[int32]uint64)
		v = *vp
	} else {
		v = rv.Interface().(map[int32]uint64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int32]uint64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int32]uint64, containerLen)
		} else {
			v = make(map[int32]uint64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int32(f.dd.decodeInt(32))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeUint(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt32Int(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int32]int)
	var v map[int32]int
	if xaddr {
		vp = rv.Addr().Interface().(*map[int32]int)
		v = *vp
	} else {
		v = rv.Interface().(map[int32]int)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int32]int{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int32]int, containerLen)
		} else {
			v = make(map[int32]int) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int32(f.dd.decodeInt(32))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int(f.dd.decodeInt(intBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt32Int32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int32]int32)
	var v map[int32]int32
	if xaddr {
		vp = rv.Addr().Interface().(*map[int32]int32)
		v = *vp
	} else {
		v = rv.Interface().(map[int32]int32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int32]int32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int32]int32, containerLen)
		} else {
			v = make(map[int32]int32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int32(f.dd.decodeInt(32))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int32(f.dd.decodeInt(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt32Int64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int32]int64)
	var v map[int32]int64
	if xaddr {
		vp = rv.Addr().Interface().(*map[int32]int64)
		v = *vp
	} else {
		v = rv.Interface().(map[int32]int64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int32]int64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int32]int64, containerLen)
		} else {
			v = make(map[int32]int64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := int32(f.dd.decodeInt(32))

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeInt(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt64Intf(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int64]interface{})
	var v map[int64]interface{}
	if xaddr {
		vp = rv.Addr().Interface().(*map[int64]interface{})
		v = *vp
	} else {
		v = rv.Interface().(map[int64]interface{})
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int64]interface{}{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int64]interface{}, containerLen)
		} else {
			v = make(map[int64]interface{}) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeInt(64)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.d.decode(&mv)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt64String(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int64]string)
	var v map[int64]string
	if xaddr {
		vp = rv.Addr().Interface().(*map[int64]string)
		v = *vp
	} else {
		v = rv.Interface().(map[int64]string)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int64]string{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int64]string, containerLen)
		} else {
			v = make(map[int64]string) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeInt(64)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeString()

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt64Uint(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int64]uint)
	var v map[int64]uint
	if xaddr {
		vp = rv.Addr().Interface().(*map[int64]uint)
		v = *vp
	} else {
		v = rv.Interface().(map[int64]uint)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int64]uint{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int64]uint, containerLen)
		} else {
			v = make(map[int64]uint) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeInt(64)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint(f.dd.decodeUint(uintBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt64Uint32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int64]uint32)
	var v map[int64]uint32
	if xaddr {
		vp = rv.Addr().Interface().(*map[int64]uint32)
		v = *vp
	} else {
		v = rv.Interface().(map[int64]uint32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int64]uint32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int64]uint32, containerLen)
		} else {
			v = make(map[int64]uint32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeInt(64)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint32(f.dd.decodeUint(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt64Uint64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int64]uint64)
	var v map[int64]uint64
	if xaddr {
		vp = rv.Addr().Interface().(*map[int64]uint64)
		v = *vp
	} else {
		v = rv.Interface().(map[int64]uint64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int64]uint64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int64]uint64, containerLen)
		} else {
			v = make(map[int64]uint64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeInt(64)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeUint(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt64Int(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int64]int)
	var v map[int64]int
	if xaddr {
		vp = rv.Addr().Interface().(*map[int64]int)
		v = *vp
	} else {
		v = rv.Interface().(map[int64]int)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int64]int{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int64]int, containerLen)
		} else {
			v = make(map[int64]int) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeInt(64)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int(f.dd.decodeInt(intBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt64Int32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int64]int32)
	var v map[int64]int32
	if xaddr {
		vp = rv.Addr().Interface().(*map[int64]int32)
		v = *vp
	} else {
		v = rv.Interface().(map[int64]int32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int64]int32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int64]int32, containerLen)
		} else {
			v = make(map[int64]int32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeInt(64)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int32(f.dd.decodeInt(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapInt64Int64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[int64]int64)
	var v map[int64]int64
	if xaddr {
		vp = rv.Addr().Interface().(*map[int64]int64)
		v = *vp
	} else {
		v = rv.Interface().(map[int64]int64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[int64]int64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[int64]int64, containerLen)
		} else {
			v = make(map[int64]int64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeInt(64)

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeInt(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapBoolBool(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[bool]bool)
	var v map[bool]bool
	if xaddr {
		vp = rv.Addr().Interface().(*map[bool]bool)
		v = *vp
	} else {
		v = rv.Interface().(map[bool]bool)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[bool]bool{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[bool]bool, containerLen)
		} else {
			v = make(map[bool]bool) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeBool()

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeBool()

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapBoolIntf(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[bool]interface{})
	var v map[bool]interface{}
	if xaddr {
		vp = rv.Addr().Interface().(*map[bool]interface{})
		v = *vp
	} else {
		v = rv.Interface().(map[bool]interface{})
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[bool]interface{}{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[bool]interface{}, containerLen)
		} else {
			v = make(map[bool]interface{}) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeBool()

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.d.decode(&mv)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapBoolString(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[bool]string)
	var v map[bool]string
	if xaddr {
		vp = rv.Addr().Interface().(*map[bool]string)
		v = *vp
	} else {
		v = rv.Interface().(map[bool]string)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[bool]string{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[bool]string, containerLen)
		} else {
			v = make(map[bool]string) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeBool()

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeString()

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapBoolUint(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[bool]uint)
	var v map[bool]uint
	if xaddr {
		vp = rv.Addr().Interface().(*map[bool]uint)
		v = *vp
	} else {
		v = rv.Interface().(map[bool]uint)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[bool]uint{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[bool]uint, containerLen)
		} else {
			v = make(map[bool]uint) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeBool()

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint(f.dd.decodeUint(uintBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapBoolUint32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[bool]uint32)
	var v map[bool]uint32
	if xaddr {
		vp = rv.Addr().Interface().(*map[bool]uint32)
		v = *vp
	} else {
		v = rv.Interface().(map[bool]uint32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[bool]uint32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[bool]uint32, containerLen)
		} else {
			v = make(map[bool]uint32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeBool()

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = uint32(f.dd.decodeUint(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapBoolUint64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[bool]uint64)
	var v map[bool]uint64
	if xaddr {
		vp = rv.Addr().Interface().(*map[bool]uint64)
		v = *vp
	} else {
		v = rv.Interface().(map[bool]uint64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[bool]uint64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[bool]uint64, containerLen)
		} else {
			v = make(map[bool]uint64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeBool()

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeUint(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapBoolInt(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[bool]int)
	var v map[bool]int
	if xaddr {
		vp = rv.Addr().Interface().(*map[bool]int)
		v = *vp
	} else {
		v = rv.Interface().(map[bool]int)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[bool]int{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[bool]int, containerLen)
		} else {
			v = make(map[bool]int) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeBool()

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int(f.dd.decodeInt(intBitsize))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapBoolInt32(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[bool]int32)
	var v map[bool]int32
	if xaddr {
		vp = rv.Addr().Interface().(*map[bool]int32)
		v = *vp
	} else {
		v = rv.Interface().(map[bool]int32)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[bool]int32{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[bool]int32, containerLen)
		} else {
			v = make(map[bool]int32) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeBool()

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = int32(f.dd.decodeInt(32))

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}

func (f *decFnInfo) fastDecMapBoolInt64(rv reflect.Value) {
	xaddr := rv.CanAddr()
	var vp (*map[bool]int64)
	var v map[bool]int64
	if xaddr {
		vp = rv.Addr().Interface().(*map[bool]int64)
		v = *vp
	} else {
		v = rv.Interface().(map[bool]int64)
	}
	if f.dd.isContainerType(valueTypeNil) {
		if xaddr {
			v = nil
			*vp = v
		} // else do nothing. We never remove from a map.
		return
	}

	containerLen := f.dd.readMapStart()
	if containerLen == 0 {
		if v == nil {
			v = map[bool]int64{}
			*vp = v
		}
		f.dd.readMapEnd()
		return
	}
	if xaddr && v == nil {
		if containerLen > 0 {
			v = make(map[bool]int64, containerLen)
		} else {
			v = make(map[bool]int64) // supports indefinite-length, etc
		}
		*vp = v
	}
	// for j := 0; j < containerLen; j++ {
	for j := 0; ; j++ {
		if containerLen >= 0 {
			if j >= containerLen {
				break
			}
		} else if f.dd.checkBreak() {
			break
		}
		if j > 0 {
			f.dd.readMapEntrySeparator()
		}
		f.dd.initReadNext()
		mk := f.dd.decodeBool()

		f.dd.readMapKVSeparator()
		mv := v[mk]
		f.dd.initReadNext()
		mv = f.dd.decodeInt(64)

		if v != nil {
			v[mk] = mv
		}
	}
	f.dd.readMapEnd()
}