vendor/github.com/ugorji/go/codec/fast-path.generated.go

   1 // +build !notfastpath
   2
   3 // Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
   4 // Use of this source code is governed by a MIT license found in the LICENSE file.
   5
   6 // Code generated from fast-path.go.tmpl - DO NOT EDIT.
   7
   8 package codec
   9
  10 // Fast path functions try to create a fast path encode or decode implementation
  11 // for common maps and slices.
  12 //
  13 // We define the functions and register then in this single file
  14 // so as not to pollute the encode.go and decode.go, and create a dependency in there.
  15 // This file can be omitted without causing a build failure.
  16 //
  17 // The advantage of fast paths is:
  18 //        - Many calls bypass reflection altogether
  19 //
  20 // Currently support
  21 //        - slice of all builtin types,
  22 //        - map of all builtin types to string or interface value
  23 //        - symmetrical maps of all builtin types (e.g. str-str, uint8-uint8)
  24 // This should provide adequate "typical" implementations.
  25 //
  26 // Note that fast track decode functions must handle values for which an address cannot be obtained.
  27 // For example:
  28 //       m2 := map[string]int{}
  29 //       p2 := []interface{}{m2}
  30 //       // decoding into p2 will bomb if fast track functions do not treat like unaddressable.
  31 //
  32
  33 import (
  34         "reflect"
  35         "sort"
  36 )
  37
  38 const fastpathEnabled = true
  39
  40 type fastpathT struct{}
  41
  42 var fastpathTV fastpathT
  43
  44 type fastpathE struct {
  45         rtid  uintptr
  46         rt    reflect.Type
  47         encfn func(*Encoder, *codecFnInfo, reflect.Value)
  48         decfn func(*Decoder, *codecFnInfo, reflect.Value)
  49 }
  50
  51 type fastpathA [271]fastpathE
  52
  53 func (x *fastpathA) index(rtid uintptr) int {
  54         // use binary search to grab the index (adapted from sort/search.go)
  55         h, i, j := 0, 0, 271 // len(x)
  56         for i < j {
  57                 h = i + (j-i)/2
  58                 if x[h].rtid < rtid {
  59                         i = h + 1
  60                 } else {
  61                         j = h
  62                 }
  63         }
  64         if i < 271 && x[i].rtid == rtid {
  65                 return i
  66         }
  67         return -1
  68 }
  69
  70 type fastpathAslice []fastpathE
  71
  72 func (x fastpathAslice) Len() int           { return len(x) }
  73 func (x fastpathAslice) Less(i, j int) bool { return x[i].rtid < x[j].rtid }
  74 func (x fastpathAslice) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
  75
  76 var fastpathAV fastpathA
  77
  78 // due to possible initialization loop error, make fastpath in an init()
  79 func init() {
  80         i := 0
  81         fn := func(v interface{},
  82                 fe func(*Encoder, *codecFnInfo, reflect.Value),
  83                 fd func(*Decoder, *codecFnInfo, reflect.Value)) (f fastpathE) {
  84                 xrt := reflect.TypeOf(v)
  85                 xptr := rt2id(xrt)
  86                 fastpathAV[i] = fastpathE{xptr, xrt, fe, fd}
  87                 i++
  88                 return
  89         }
  90
  91         fn([]interface{}(nil), (*Encoder).fastpathEncSliceIntfR, (*Decoder).fastpathDecSliceIntfR)
  92         fn([]string(nil), (*Encoder).fastpathEncSliceStringR, (*Decoder).fastpathDecSliceStringR)
  93         fn([]float32(nil), (*Encoder).fastpathEncSliceFloat32R, (*Decoder).fastpathDecSliceFloat32R)
  94         fn([]float64(nil), (*Encoder).fastpathEncSliceFloat64R, (*Decoder).fastpathDecSliceFloat64R)
  95         fn([]uint(nil), (*Encoder).fastpathEncSliceUintR, (*Decoder).fastpathDecSliceUintR)
  96         fn([]uint16(nil), (*Encoder).fastpathEncSliceUint16R, (*Decoder).fastpathDecSliceUint16R)
  97         fn([]uint32(nil), (*Encoder).fastpathEncSliceUint32R, (*Decoder).fastpathDecSliceUint32R)
  98         fn([]uint64(nil), (*Encoder).fastpathEncSliceUint64R, (*Decoder).fastpathDecSliceUint64R)
  99         fn([]uintptr(nil), (*Encoder).fastpathEncSliceUintptrR, (*Decoder).fastpathDecSliceUintptrR)
 100         fn([]int(nil), (*Encoder).fastpathEncSliceIntR, (*Decoder).fastpathDecSliceIntR)
 101         fn([]int8(nil), (*Encoder).fastpathEncSliceInt8R, (*Decoder).fastpathDecSliceInt8R)
 102         fn([]int16(nil), (*Encoder).fastpathEncSliceInt16R, (*Decoder).fastpathDecSliceInt16R)
 103         fn([]int32(nil), (*Encoder).fastpathEncSliceInt32R, (*Decoder).fastpathDecSliceInt32R)
 104         fn([]int64(nil), (*Encoder).fastpathEncSliceInt64R, (*Decoder).fastpathDecSliceInt64R)
 105         fn([]bool(nil), (*Encoder).fastpathEncSliceBoolR, (*Decoder).fastpathDecSliceBoolR)
 106
 107         fn(map[interface{}]interface{}(nil), (*Encoder).fastpathEncMapIntfIntfR, (*Decoder).fastpathDecMapIntfIntfR)
 108         fn(map[interface{}]string(nil), (*Encoder).fastpathEncMapIntfStringR, (*Decoder).fastpathDecMapIntfStringR)
 109         fn(map[interface{}]uint(nil), (*Encoder).fastpathEncMapIntfUintR, (*Decoder).fastpathDecMapIntfUintR)
 110         fn(map[interface{}]uint8(nil), (*Encoder).fastpathEncMapIntfUint8R, (*Decoder).fastpathDecMapIntfUint8R)
 111         fn(map[interface{}]uint16(nil), (*Encoder).fastpathEncMapIntfUint16R, (*Decoder).fastpathDecMapIntfUint16R)
 112         fn(map[interface{}]uint32(nil), (*Encoder).fastpathEncMapIntfUint32R, (*Decoder).fastpathDecMapIntfUint32R)
 113         fn(map[interface{}]uint64(nil), (*Encoder).fastpathEncMapIntfUint64R, (*Decoder).fastpathDecMapIntfUint64R)
 114         fn(map[interface{}]uintptr(nil), (*Encoder).fastpathEncMapIntfUintptrR, (*Decoder).fastpathDecMapIntfUintptrR)
 115         fn(map[interface{}]int(nil), (*Encoder).fastpathEncMapIntfIntR, (*Decoder).fastpathDecMapIntfIntR)
 116         fn(map[interface{}]int8(nil), (*Encoder).fastpathEncMapIntfInt8R, (*Decoder).fastpathDecMapIntfInt8R)
 117         fn(map[interface{}]int16(nil), (*Encoder).fastpathEncMapIntfInt16R, (*Decoder).fastpathDecMapIntfInt16R)
 118         fn(map[interface{}]int32(nil), (*Encoder).fastpathEncMapIntfInt32R, (*Decoder).fastpathDecMapIntfInt32R)
 119         fn(map[interface{}]int64(nil), (*Encoder).fastpathEncMapIntfInt64R, (*Decoder).fastpathDecMapIntfInt64R)
 120         fn(map[interface{}]float32(nil), (*Encoder).fastpathEncMapIntfFloat32R, (*Decoder).fastpathDecMapIntfFloat32R)
 121         fn(map[interface{}]float64(nil), (*Encoder).fastpathEncMapIntfFloat64R, (*Decoder).fastpathDecMapIntfFloat64R)
 122         fn(map[interface{}]bool(nil), (*Encoder).fastpathEncMapIntfBoolR, (*Decoder).fastpathDecMapIntfBoolR)
 123         fn(map[string]interface{}(nil), (*Encoder).fastpathEncMapStringIntfR, (*Decoder).fastpathDecMapStringIntfR)
 124         fn(map[string]string(nil), (*Encoder).fastpathEncMapStringStringR, (*Decoder).fastpathDecMapStringStringR)
 125         fn(map[string]uint(nil), (*Encoder).fastpathEncMapStringUintR, (*Decoder).fastpathDecMapStringUintR)
 126         fn(map[string]uint8(nil), (*Encoder).fastpathEncMapStringUint8R, (*Decoder).fastpathDecMapStringUint8R)
 127         fn(map[string]uint16(nil), (*Encoder).fastpathEncMapStringUint16R, (*Decoder).fastpathDecMapStringUint16R)
 128         fn(map[string]uint32(nil), (*Encoder).fastpathEncMapStringUint32R, (*Decoder).fastpathDecMapStringUint32R)
 129         fn(map[string]uint64(nil), (*Encoder).fastpathEncMapStringUint64R, (*Decoder).fastpathDecMapStringUint64R)
 130         fn(map[string]uintptr(nil), (*Encoder).fastpathEncMapStringUintptrR, (*Decoder).fastpathDecMapStringUintptrR)
 131         fn(map[string]int(nil), (*Encoder).fastpathEncMapStringIntR, (*Decoder).fastpathDecMapStringIntR)
 132         fn(map[string]int8(nil), (*Encoder).fastpathEncMapStringInt8R, (*Decoder).fastpathDecMapStringInt8R)
 133         fn(map[string]int16(nil), (*Encoder).fastpathEncMapStringInt16R, (*Decoder).fastpathDecMapStringInt16R)
 134         fn(map[string]int32(nil), (*Encoder).fastpathEncMapStringInt32R, (*Decoder).fastpathDecMapStringInt32R)
 135         fn(map[string]int64(nil), (*Encoder).fastpathEncMapStringInt64R, (*Decoder).fastpathDecMapStringInt64R)
 136         fn(map[string]float32(nil), (*Encoder).fastpathEncMapStringFloat32R, (*Decoder).fastpathDecMapStringFloat32R)
 137         fn(map[string]float64(nil), (*Encoder).fastpathEncMapStringFloat64R, (*Decoder).fastpathDecMapStringFloat64R)
 138         fn(map[string]bool(nil), (*Encoder).fastpathEncMapStringBoolR, (*Decoder).fastpathDecMapStringBoolR)
 139         fn(map[float32]interface{}(nil), (*Encoder).fastpathEncMapFloat32IntfR, (*Decoder).fastpathDecMapFloat32IntfR)
 140         fn(map[float32]string(nil), (*Encoder).fastpathEncMapFloat32StringR, (*Decoder).fastpathDecMapFloat32StringR)
 141         fn(map[float32]uint(nil), (*Encoder).fastpathEncMapFloat32UintR, (*Decoder).fastpathDecMapFloat32UintR)
 142         fn(map[float32]uint8(nil), (*Encoder).fastpathEncMapFloat32Uint8R, (*Decoder).fastpathDecMapFloat32Uint8R)
 143         fn(map[float32]uint16(nil), (*Encoder).fastpathEncMapFloat32Uint16R, (*Decoder).fastpathDecMapFloat32Uint16R)
 144         fn(map[float32]uint32(nil), (*Encoder).fastpathEncMapFloat32Uint32R, (*Decoder).fastpathDecMapFloat32Uint32R)
 145         fn(map[float32]uint64(nil), (*Encoder).fastpathEncMapFloat32Uint64R, (*Decoder).fastpathDecMapFloat32Uint64R)
 146         fn(map[float32]uintptr(nil), (*Encoder).fastpathEncMapFloat32UintptrR, (*Decoder).fastpathDecMapFloat32UintptrR)
 147         fn(map[float32]int(nil), (*Encoder).fastpathEncMapFloat32IntR, (*Decoder).fastpathDecMapFloat32IntR)
 148         fn(map[float32]int8(nil), (*Encoder).fastpathEncMapFloat32Int8R, (*Decoder).fastpathDecMapFloat32Int8R)
 149         fn(map[float32]int16(nil), (*Encoder).fastpathEncMapFloat32Int16R, (*Decoder).fastpathDecMapFloat32Int16R)
 150         fn(map[float32]int32(nil), (*Encoder).fastpathEncMapFloat32Int32R, (*Decoder).fastpathDecMapFloat32Int32R)
 151         fn(map[float32]int64(nil), (*Encoder).fastpathEncMapFloat32Int64R, (*Decoder).fastpathDecMapFloat32Int64R)
 152         fn(map[float32]float32(nil), (*Encoder).fastpathEncMapFloat32Float32R, (*Decoder).fastpathDecMapFloat32Float32R)
 153         fn(map[float32]float64(nil), (*Encoder).fastpathEncMapFloat32Float64R, (*Decoder).fastpathDecMapFloat32Float64R)
 154         fn(map[float32]bool(nil), (*Encoder).fastpathEncMapFloat32BoolR, (*Decoder).fastpathDecMapFloat32BoolR)
 155         fn(map[float64]interface{}(nil), (*Encoder).fastpathEncMapFloat64IntfR, (*Decoder).fastpathDecMapFloat64IntfR)
 156         fn(map[float64]string(nil), (*Encoder).fastpathEncMapFloat64StringR, (*Decoder).fastpathDecMapFloat64StringR)
 157         fn(map[float64]uint(nil), (*Encoder).fastpathEncMapFloat64UintR, (*Decoder).fastpathDecMapFloat64UintR)
 158         fn(map[float64]uint8(nil), (*Encoder).fastpathEncMapFloat64Uint8R, (*Decoder).fastpathDecMapFloat64Uint8R)
 159         fn(map[float64]uint16(nil), (*Encoder).fastpathEncMapFloat64Uint16R, (*Decoder).fastpathDecMapFloat64Uint16R)
 160         fn(map[float64]uint32(nil), (*Encoder).fastpathEncMapFloat64Uint32R, (*Decoder).fastpathDecMapFloat64Uint32R)
 161         fn(map[float64]uint64(nil), (*Encoder).fastpathEncMapFloat64Uint64R, (*Decoder).fastpathDecMapFloat64Uint64R)
 162         fn(map[float64]uintptr(nil), (*Encoder).fastpathEncMapFloat64UintptrR, (*Decoder).fastpathDecMapFloat64UintptrR)
 163         fn(map[float64]int(nil), (*Encoder).fastpathEncMapFloat64IntR, (*Decoder).fastpathDecMapFloat64IntR)
 164         fn(map[float64]int8(nil), (*Encoder).fastpathEncMapFloat64Int8R, (*Decoder).fastpathDecMapFloat64Int8R)
 165         fn(map[float64]int16(nil), (*Encoder).fastpathEncMapFloat64Int16R, (*Decoder).fastpathDecMapFloat64Int16R)
 166         fn(map[float64]int32(nil), (*Encoder).fastpathEncMapFloat64Int32R, (*Decoder).fastpathDecMapFloat64Int32R)
 167         fn(map[float64]int64(nil), (*Encoder).fastpathEncMapFloat64Int64R, (*Decoder).fastpathDecMapFloat64Int64R)
 168         fn(map[float64]float32(nil), (*Encoder).fastpathEncMapFloat64Float32R, (*Decoder).fastpathDecMapFloat64Float32R)
 169         fn(map[float64]float64(nil), (*Encoder).fastpathEncMapFloat64Float64R, (*Decoder).fastpathDecMapFloat64Float64R)
 170         fn(map[float64]bool(nil), (*Encoder).fastpathEncMapFloat64BoolR, (*Decoder).fastpathDecMapFloat64BoolR)
 171         fn(map[uint]interface{}(nil), (*Encoder).fastpathEncMapUintIntfR, (*Decoder).fastpathDecMapUintIntfR)
 172         fn(map[uint]string(nil), (*Encoder).fastpathEncMapUintStringR, (*Decoder).fastpathDecMapUintStringR)
 173         fn(map[uint]uint(nil), (*Encoder).fastpathEncMapUintUintR, (*Decoder).fastpathDecMapUintUintR)
 174         fn(map[uint]uint8(nil), (*Encoder).fastpathEncMapUintUint8R, (*Decoder).fastpathDecMapUintUint8R)
 175         fn(map[uint]uint16(nil), (*Encoder).fastpathEncMapUintUint16R, (*Decoder).fastpathDecMapUintUint16R)
 176         fn(map[uint]uint32(nil), (*Encoder).fastpathEncMapUintUint32R, (*Decoder).fastpathDecMapUintUint32R)
 177         fn(map[uint]uint64(nil), (*Encoder).fastpathEncMapUintUint64R, (*Decoder).fastpathDecMapUintUint64R)
 178         fn(map[uint]uintptr(nil), (*Encoder).fastpathEncMapUintUintptrR, (*Decoder).fastpathDecMapUintUintptrR)
 179         fn(map[uint]int(nil), (*Encoder).fastpathEncMapUintIntR, (*Decoder).fastpathDecMapUintIntR)
 180         fn(map[uint]int8(nil), (*Encoder).fastpathEncMapUintInt8R, (*Decoder).fastpathDecMapUintInt8R)
 181         fn(map[uint]int16(nil), (*Encoder).fastpathEncMapUintInt16R, (*Decoder).fastpathDecMapUintInt16R)
 182         fn(map[uint]int32(nil), (*Encoder).fastpathEncMapUintInt32R, (*Decoder).fastpathDecMapUintInt32R)
 183         fn(map[uint]int64(nil), (*Encoder).fastpathEncMapUintInt64R, (*Decoder).fastpathDecMapUintInt64R)
 184         fn(map[uint]float32(nil), (*Encoder).fastpathEncMapUintFloat32R, (*Decoder).fastpathDecMapUintFloat32R)
 185         fn(map[uint]float64(nil), (*Encoder).fastpathEncMapUintFloat64R, (*Decoder).fastpathDecMapUintFloat64R)
 186         fn(map[uint]bool(nil), (*Encoder).fastpathEncMapUintBoolR, (*Decoder).fastpathDecMapUintBoolR)
 187         fn(map[uint8]interface{}(nil), (*Encoder).fastpathEncMapUint8IntfR, (*Decoder).fastpathDecMapUint8IntfR)
 188         fn(map[uint8]string(nil), (*Encoder).fastpathEncMapUint8StringR, (*Decoder).fastpathDecMapUint8StringR)
 189         fn(map[uint8]uint(nil), (*Encoder).fastpathEncMapUint8UintR, (*Decoder).fastpathDecMapUint8UintR)
 190         fn(map[uint8]uint8(nil), (*Encoder).fastpathEncMapUint8Uint8R, (*Decoder).fastpathDecMapUint8Uint8R)
 191         fn(map[uint8]uint16(nil), (*Encoder).fastpathEncMapUint8Uint16R, (*Decoder).fastpathDecMapUint8Uint16R)
 192         fn(map[uint8]uint32(nil), (*Encoder).fastpathEncMapUint8Uint32R, (*Decoder).fastpathDecMapUint8Uint32R)
 193         fn(map[uint8]uint64(nil), (*Encoder).fastpathEncMapUint8Uint64R, (*Decoder).fastpathDecMapUint8Uint64R)
 194         fn(map[uint8]uintptr(nil), (*Encoder).fastpathEncMapUint8UintptrR, (*Decoder).fastpathDecMapUint8UintptrR)
 195         fn(map[uint8]int(nil), (*Encoder).fastpathEncMapUint8IntR, (*Decoder).fastpathDecMapUint8IntR)
 196         fn(map[uint8]int8(nil), (*Encoder).fastpathEncMapUint8Int8R, (*Decoder).fastpathDecMapUint8Int8R)
 197         fn(map[uint8]int16(nil), (*Encoder).fastpathEncMapUint8Int16R, (*Decoder).fastpathDecMapUint8Int16R)
 198         fn(map[uint8]int32(nil), (*Encoder).fastpathEncMapUint8Int32R, (*Decoder).fastpathDecMapUint8Int32R)
 199         fn(map[uint8]int64(nil), (*Encoder).fastpathEncMapUint8Int64R, (*Decoder).fastpathDecMapUint8Int64R)
 200         fn(map[uint8]float32(nil), (*Encoder).fastpathEncMapUint8Float32R, (*Decoder).fastpathDecMapUint8Float32R)
 201         fn(map[uint8]float64(nil), (*Encoder).fastpathEncMapUint8Float64R, (*Decoder).fastpathDecMapUint8Float64R)
 202         fn(map[uint8]bool(nil), (*Encoder).fastpathEncMapUint8BoolR, (*Decoder).fastpathDecMapUint8BoolR)
 203         fn(map[uint16]interface{}(nil), (*Encoder).fastpathEncMapUint16IntfR, (*Decoder).fastpathDecMapUint16IntfR)
 204         fn(map[uint16]string(nil), (*Encoder).fastpathEncMapUint16StringR, (*Decoder).fastpathDecMapUint16StringR)
 205         fn(map[uint16]uint(nil), (*Encoder).fastpathEncMapUint16UintR, (*Decoder).fastpathDecMapUint16UintR)
 206         fn(map[uint16]uint8(nil), (*Encoder).fastpathEncMapUint16Uint8R, (*Decoder).fastpathDecMapUint16Uint8R)
 207         fn(map[uint16]uint16(nil), (*Encoder).fastpathEncMapUint16Uint16R, (*Decoder).fastpathDecMapUint16Uint16R)
 208         fn(map[uint16]uint32(nil), (*Encoder).fastpathEncMapUint16Uint32R, (*Decoder).fastpathDecMapUint16Uint32R)
 209         fn(map[uint16]uint64(nil), (*Encoder).fastpathEncMapUint16Uint64R, (*Decoder).fastpathDecMapUint16Uint64R)
 210         fn(map[uint16]uintptr(nil), (*Encoder).fastpathEncMapUint16UintptrR, (*Decoder).fastpathDecMapUint16UintptrR)
 211         fn(map[uint16]int(nil), (*Encoder).fastpathEncMapUint16IntR, (*Decoder).fastpathDecMapUint16IntR)
 212         fn(map[uint16]int8(nil), (*Encoder).fastpathEncMapUint16Int8R, (*Decoder).fastpathDecMapUint16Int8R)
 213         fn(map[uint16]int16(nil), (*Encoder).fastpathEncMapUint16Int16R, (*Decoder).fastpathDecMapUint16Int16R)
 214         fn(map[uint16]int32(nil), (*Encoder).fastpathEncMapUint16Int32R, (*Decoder).fastpathDecMapUint16Int32R)
 215         fn(map[uint16]int64(nil), (*Encoder).fastpathEncMapUint16Int64R, (*Decoder).fastpathDecMapUint16Int64R)
 216         fn(map[uint16]float32(nil), (*Encoder).fastpathEncMapUint16Float32R, (*Decoder).fastpathDecMapUint16Float32R)
 217         fn(map[uint16]float64(nil), (*Encoder).fastpathEncMapUint16Float64R, (*Decoder).fastpathDecMapUint16Float64R)
 218         fn(map[uint16]bool(nil), (*Encoder).fastpathEncMapUint16BoolR, (*Decoder).fastpathDecMapUint16BoolR)
 219         fn(map[uint32]interface{}(nil), (*Encoder).fastpathEncMapUint32IntfR, (*Decoder).fastpathDecMapUint32IntfR)
 220         fn(map[uint32]string(nil), (*Encoder).fastpathEncMapUint32StringR, (*Decoder).fastpathDecMapUint32StringR)
 221         fn(map[uint32]uint(nil), (*Encoder).fastpathEncMapUint32UintR, (*Decoder).fastpathDecMapUint32UintR)
 222         fn(map[uint32]uint8(nil), (*Encoder).fastpathEncMapUint32Uint8R, (*Decoder).fastpathDecMapUint32Uint8R)
 223         fn(map[uint32]uint16(nil), (*Encoder).fastpathEncMapUint32Uint16R, (*Decoder).fastpathDecMapUint32Uint16R)
 224         fn(map[uint32]uint32(nil), (*Encoder).fastpathEncMapUint32Uint32R, (*Decoder).fastpathDecMapUint32Uint32R)
 225         fn(map[uint32]uint64(nil), (*Encoder).fastpathEncMapUint32Uint64R, (*Decoder).fastpathDecMapUint32Uint64R)
 226         fn(map[uint32]uintptr(nil), (*Encoder).fastpathEncMapUint32UintptrR, (*Decoder).fastpathDecMapUint32UintptrR)
 227         fn(map[uint32]int(nil), (*Encoder).fastpathEncMapUint32IntR, (*Decoder).fastpathDecMapUint32IntR)
 228         fn(map[uint32]int8(nil), (*Encoder).fastpathEncMapUint32Int8R, (*Decoder).fastpathDecMapUint32Int8R)
 229         fn(map[uint32]int16(nil), (*Encoder).fastpathEncMapUint32Int16R, (*Decoder).fastpathDecMapUint32Int16R)
 230         fn(map[uint32]int32(nil), (*Encoder).fastpathEncMapUint32Int32R, (*Decoder).fastpathDecMapUint32Int32R)
 231         fn(map[uint32]int64(nil), (*Encoder).fastpathEncMapUint32Int64R, (*Decoder).fastpathDecMapUint32Int64R)
 232         fn(map[uint32]float32(nil), (*Encoder).fastpathEncMapUint32Float32R, (*Decoder).fastpathDecMapUint32Float32R)
 233         fn(map[uint32]float64(nil), (*Encoder).fastpathEncMapUint32Float64R, (*Decoder).fastpathDecMapUint32Float64R)
 234         fn(map[uint32]bool(nil), (*Encoder).fastpathEncMapUint32BoolR, (*Decoder).fastpathDecMapUint32BoolR)
 235         fn(map[uint64]interface{}(nil), (*Encoder).fastpathEncMapUint64IntfR, (*Decoder).fastpathDecMapUint64IntfR)
 236         fn(map[uint64]string(nil), (*Encoder).fastpathEncMapUint64StringR, (*Decoder).fastpathDecMapUint64StringR)
 237         fn(map[uint64]uint(nil), (*Encoder).fastpathEncMapUint64UintR, (*Decoder).fastpathDecMapUint64UintR)
 238         fn(map[uint64]uint8(nil), (*Encoder).fastpathEncMapUint64Uint8R, (*Decoder).fastpathDecMapUint64Uint8R)
 239         fn(map[uint64]uint16(nil), (*Encoder).fastpathEncMapUint64Uint16R, (*Decoder).fastpathDecMapUint64Uint16R)
 240         fn(map[uint64]uint32(nil), (*Encoder).fastpathEncMapUint64Uint32R, (*Decoder).fastpathDecMapUint64Uint32R)
 241         fn(map[uint64]uint64(nil), (*Encoder).fastpathEncMapUint64Uint64R, (*Decoder).fastpathDecMapUint64Uint64R)
 242         fn(map[uint64]uintptr(nil), (*Encoder).fastpathEncMapUint64UintptrR, (*Decoder).fastpathDecMapUint64UintptrR)
 243         fn(map[uint64]int(nil), (*Encoder).fastpathEncMapUint64IntR, (*Decoder).fastpathDecMapUint64IntR)
 244         fn(map[uint64]int8(nil), (*Encoder).fastpathEncMapUint64Int8R, (*Decoder).fastpathDecMapUint64Int8R)
 245         fn(map[uint64]int16(nil), (*Encoder).fastpathEncMapUint64Int16R, (*Decoder).fastpathDecMapUint64Int16R)
 246         fn(map[uint64]int32(nil), (*Encoder).fastpathEncMapUint64Int32R, (*Decoder).fastpathDecMapUint64Int32R)
 247         fn(map[uint64]int64(nil), (*Encoder).fastpathEncMapUint64Int64R, (*Decoder).fastpathDecMapUint64Int64R)
 248         fn(map[uint64]float32(nil), (*Encoder).fastpathEncMapUint64Float32R, (*Decoder).fastpathDecMapUint64Float32R)
 249         fn(map[uint64]float64(nil), (*Encoder).fastpathEncMapUint64Float64R, (*Decoder).fastpathDecMapUint64Float64R)
 250         fn(map[uint64]bool(nil), (*Encoder).fastpathEncMapUint64BoolR, (*Decoder).fastpathDecMapUint64BoolR)
 251         fn(map[uintptr]interface{}(nil), (*Encoder).fastpathEncMapUintptrIntfR, (*Decoder).fastpathDecMapUintptrIntfR)
 252         fn(map[uintptr]string(nil), (*Encoder).fastpathEncMapUintptrStringR, (*Decoder).fastpathDecMapUintptrStringR)
 253         fn(map[uintptr]uint(nil), (*Encoder).fastpathEncMapUintptrUintR, (*Decoder).fastpathDecMapUintptrUintR)
 254         fn(map[uintptr]uint8(nil), (*Encoder).fastpathEncMapUintptrUint8R, (*Decoder).fastpathDecMapUintptrUint8R)
 255         fn(map[uintptr]uint16(nil), (*Encoder).fastpathEncMapUintptrUint16R, (*Decoder).fastpathDecMapUintptrUint16R)
 256         fn(map[uintptr]uint32(nil), (*Encoder).fastpathEncMapUintptrUint32R, (*Decoder).fastpathDecMapUintptrUint32R)
 257         fn(map[uintptr]uint64(nil), (*Encoder).fastpathEncMapUintptrUint64R, (*Decoder).fastpathDecMapUintptrUint64R)
 258         fn(map[uintptr]uintptr(nil), (*Encoder).fastpathEncMapUintptrUintptrR, (*Decoder).fastpathDecMapUintptrUintptrR)
 259         fn(map[uintptr]int(nil), (*Encoder).fastpathEncMapUintptrIntR, (*Decoder).fastpathDecMapUintptrIntR)
 260         fn(map[uintptr]int8(nil), (*Encoder).fastpathEncMapUintptrInt8R, (*Decoder).fastpathDecMapUintptrInt8R)
 261         fn(map[uintptr]int16(nil), (*Encoder).fastpathEncMapUintptrInt16R, (*Decoder).fastpathDecMapUintptrInt16R)
 262         fn(map[uintptr]int32(nil), (*Encoder).fastpathEncMapUintptrInt32R, (*Decoder).fastpathDecMapUintptrInt32R)
 263         fn(map[uintptr]int64(nil), (*Encoder).fastpathEncMapUintptrInt64R, (*Decoder).fastpathDecMapUintptrInt64R)
 264         fn(map[uintptr]float32(nil), (*Encoder).fastpathEncMapUintptrFloat32R, (*Decoder).fastpathDecMapUintptrFloat32R)
 265         fn(map[uintptr]float64(nil), (*Encoder).fastpathEncMapUintptrFloat64R, (*Decoder).fastpathDecMapUintptrFloat64R)
 266         fn(map[uintptr]bool(nil), (*Encoder).fastpathEncMapUintptrBoolR, (*Decoder).fastpathDecMapUintptrBoolR)
 267         fn(map[int]interface{}(nil), (*Encoder).fastpathEncMapIntIntfR, (*Decoder).fastpathDecMapIntIntfR)
 268         fn(map[int]string(nil), (*Encoder).fastpathEncMapIntStringR, (*Decoder).fastpathDecMapIntStringR)
 269         fn(map[int]uint(nil), (*Encoder).fastpathEncMapIntUintR, (*Decoder).fastpathDecMapIntUintR)
 270         fn(map[int]uint8(nil), (*Encoder).fastpathEncMapIntUint8R, (*Decoder).fastpathDecMapIntUint8R)
 271         fn(map[int]uint16(nil), (*Encoder).fastpathEncMapIntUint16R, (*Decoder).fastpathDecMapIntUint16R)
 272         fn(map[int]uint32(nil), (*Encoder).fastpathEncMapIntUint32R, (*Decoder).fastpathDecMapIntUint32R)
 273         fn(map[int]uint64(nil), (*Encoder).fastpathEncMapIntUint64R, (*Decoder).fastpathDecMapIntUint64R)
 274         fn(map[int]uintptr(nil), (*Encoder).fastpathEncMapIntUintptrR, (*Decoder).fastpathDecMapIntUintptrR)
 275         fn(map[int]int(nil), (*Encoder).fastpathEncMapIntIntR, (*Decoder).fastpathDecMapIntIntR)
 276         fn(map[int]int8(nil), (*Encoder).fastpathEncMapIntInt8R, (*Decoder).fastpathDecMapIntInt8R)
 277         fn(map[int]int16(nil), (*Encoder).fastpathEncMapIntInt16R, (*Decoder).fastpathDecMapIntInt16R)
 278         fn(map[int]int32(nil), (*Encoder).fastpathEncMapIntInt32R, (*Decoder).fastpathDecMapIntInt32R)
 279         fn(map[int]int64(nil), (*Encoder).fastpathEncMapIntInt64R, (*Decoder).fastpathDecMapIntInt64R)
 280         fn(map[int]float32(nil), (*Encoder).fastpathEncMapIntFloat32R, (*Decoder).fastpathDecMapIntFloat32R)
 281         fn(map[int]float64(nil), (*Encoder).fastpathEncMapIntFloat64R, (*Decoder).fastpathDecMapIntFloat64R)
 282         fn(map[int]bool(nil), (*Encoder).fastpathEncMapIntBoolR, (*Decoder).fastpathDecMapIntBoolR)
 283         fn(map[int8]interface{}(nil), (*Encoder).fastpathEncMapInt8IntfR, (*Decoder).fastpathDecMapInt8IntfR)
 284         fn(map[int8]string(nil), (*Encoder).fastpathEncMapInt8StringR, (*Decoder).fastpathDecMapInt8StringR)
 285         fn(map[int8]uint(nil), (*Encoder).fastpathEncMapInt8UintR, (*Decoder).fastpathDecMapInt8UintR)
 286         fn(map[int8]uint8(nil), (*Encoder).fastpathEncMapInt8Uint8R, (*Decoder).fastpathDecMapInt8Uint8R)
 287         fn(map[int8]uint16(nil), (*Encoder).fastpathEncMapInt8Uint16R, (*Decoder).fastpathDecMapInt8Uint16R)
 288         fn(map[int8]uint32(nil), (*Encoder).fastpathEncMapInt8Uint32R, (*Decoder).fastpathDecMapInt8Uint32R)
 289         fn(map[int8]uint64(nil), (*Encoder).fastpathEncMapInt8Uint64R, (*Decoder).fastpathDecMapInt8Uint64R)
 290         fn(map[int8]uintptr(nil), (*Encoder).fastpathEncMapInt8UintptrR, (*Decoder).fastpathDecMapInt8UintptrR)
 291         fn(map[int8]int(nil), (*Encoder).fastpathEncMapInt8IntR, (*Decoder).fastpathDecMapInt8IntR)
 292         fn(map[int8]int8(nil), (*Encoder).fastpathEncMapInt8Int8R, (*Decoder).fastpathDecMapInt8Int8R)
 293         fn(map[int8]int16(nil), (*Encoder).fastpathEncMapInt8Int16R, (*Decoder).fastpathDecMapInt8Int16R)
 294         fn(map[int8]int32(nil), (*Encoder).fastpathEncMapInt8Int32R, (*Decoder).fastpathDecMapInt8Int32R)
 295         fn(map[int8]int64(nil), (*Encoder).fastpathEncMapInt8Int64R, (*Decoder).fastpathDecMapInt8Int64R)
 296         fn(map[int8]float32(nil), (*Encoder).fastpathEncMapInt8Float32R, (*Decoder).fastpathDecMapInt8Float32R)
 297         fn(map[int8]float64(nil), (*Encoder).fastpathEncMapInt8Float64R, (*Decoder).fastpathDecMapInt8Float64R)
 298         fn(map[int8]bool(nil), (*Encoder).fastpathEncMapInt8BoolR, (*Decoder).fastpathDecMapInt8BoolR)
 299         fn(map[int16]interface{}(nil), (*Encoder).fastpathEncMapInt16IntfR, (*Decoder).fastpathDecMapInt16IntfR)
 300         fn(map[int16]string(nil), (*Encoder).fastpathEncMapInt16StringR, (*Decoder).fastpathDecMapInt16StringR)
 301         fn(map[int16]uint(nil), (*Encoder).fastpathEncMapInt16UintR, (*Decoder).fastpathDecMapInt16UintR)
 302         fn(map[int16]uint8(nil), (*Encoder).fastpathEncMapInt16Uint8R, (*Decoder).fastpathDecMapInt16Uint8R)
 303         fn(map[int16]uint16(nil), (*Encoder).fastpathEncMapInt16Uint16R, (*Decoder).fastpathDecMapInt16Uint16R)
 304         fn(map[int16]uint32(nil), (*Encoder).fastpathEncMapInt16Uint32R, (*Decoder).fastpathDecMapInt16Uint32R)
 305         fn(map[int16]uint64(nil), (*Encoder).fastpathEncMapInt16Uint64R, (*Decoder).fastpathDecMapInt16Uint64R)
 306         fn(map[int16]uintptr(nil), (*Encoder).fastpathEncMapInt16UintptrR, (*Decoder).fastpathDecMapInt16UintptrR)
 307         fn(map[int16]int(nil), (*Encoder).fastpathEncMapInt16IntR, (*Decoder).fastpathDecMapInt16IntR)
 308         fn(map[int16]int8(nil), (*Encoder).fastpathEncMapInt16Int8R, (*Decoder).fastpathDecMapInt16Int8R)
 309         fn(map[int16]int16(nil), (*Encoder).fastpathEncMapInt16Int16R, (*Decoder).fastpathDecMapInt16Int16R)
 310         fn(map[int16]int32(nil), (*Encoder).fastpathEncMapInt16Int32R, (*Decoder).fastpathDecMapInt16Int32R)
 311         fn(map[int16]int64(nil), (*Encoder).fastpathEncMapInt16Int64R, (*Decoder).fastpathDecMapInt16Int64R)
 312         fn(map[int16]float32(nil), (*Encoder).fastpathEncMapInt16Float32R, (*Decoder).fastpathDecMapInt16Float32R)
 313         fn(map[int16]float64(nil), (*Encoder).fastpathEncMapInt16Float64R, (*Decoder).fastpathDecMapInt16Float64R)
 314         fn(map[int16]bool(nil), (*Encoder).fastpathEncMapInt16BoolR, (*Decoder).fastpathDecMapInt16BoolR)
 315         fn(map[int32]interface{}(nil), (*Encoder).fastpathEncMapInt32IntfR, (*Decoder).fastpathDecMapInt32IntfR)
 316         fn(map[int32]string(nil), (*Encoder).fastpathEncMapInt32StringR, (*Decoder).fastpathDecMapInt32StringR)
 317         fn(map[int32]uint(nil), (*Encoder).fastpathEncMapInt32UintR, (*Decoder).fastpathDecMapInt32UintR)
 318         fn(map[int32]uint8(nil), (*Encoder).fastpathEncMapInt32Uint8R, (*Decoder).fastpathDecMapInt32Uint8R)
 319         fn(map[int32]uint16(nil), (*Encoder).fastpathEncMapInt32Uint16R, (*Decoder).fastpathDecMapInt32Uint16R)
 320         fn(map[int32]uint32(nil), (*Encoder).fastpathEncMapInt32Uint32R, (*Decoder).fastpathDecMapInt32Uint32R)
 321         fn(map[int32]uint64(nil), (*Encoder).fastpathEncMapInt32Uint64R, (*Decoder).fastpathDecMapInt32Uint64R)
 322         fn(map[int32]uintptr(nil), (*Encoder).fastpathEncMapInt32UintptrR, (*Decoder).fastpathDecMapInt32UintptrR)
 323         fn(map[int32]int(nil), (*Encoder).fastpathEncMapInt32IntR, (*Decoder).fastpathDecMapInt32IntR)
 324         fn(map[int32]int8(nil), (*Encoder).fastpathEncMapInt32Int8R, (*Decoder).fastpathDecMapInt32Int8R)
 325         fn(map[int32]int16(nil), (*Encoder).fastpathEncMapInt32Int16R, (*Decoder).fastpathDecMapInt32Int16R)
 326         fn(map[int32]int32(nil), (*Encoder).fastpathEncMapInt32Int32R, (*Decoder).fastpathDecMapInt32Int32R)
 327         fn(map[int32]int64(nil), (*Encoder).fastpathEncMapInt32Int64R, (*Decoder).fastpathDecMapInt32Int64R)
 328         fn(map[int32]float32(nil), (*Encoder).fastpathEncMapInt32Float32R, (*Decoder).fastpathDecMapInt32Float32R)
 329         fn(map[int32]float64(nil), (*Encoder).fastpathEncMapInt32Float64R, (*Decoder).fastpathDecMapInt32Float64R)
 330         fn(map[int32]bool(nil), (*Encoder).fastpathEncMapInt32BoolR, (*Decoder).fastpathDecMapInt32BoolR)
 331         fn(map[int64]interface{}(nil), (*Encoder).fastpathEncMapInt64IntfR, (*Decoder).fastpathDecMapInt64IntfR)
 332         fn(map[int64]string(nil), (*Encoder).fastpathEncMapInt64StringR, (*Decoder).fastpathDecMapInt64StringR)
 333         fn(map[int64]uint(nil), (*Encoder).fastpathEncMapInt64UintR, (*Decoder).fastpathDecMapInt64UintR)
 334         fn(map[int64]uint8(nil), (*Encoder).fastpathEncMapInt64Uint8R, (*Decoder).fastpathDecMapInt64Uint8R)
 335         fn(map[int64]uint16(nil), (*Encoder).fastpathEncMapInt64Uint16R, (*Decoder).fastpathDecMapInt64Uint16R)
 336         fn(map[int64]uint32(nil), (*Encoder).fastpathEncMapInt64Uint32R, (*Decoder).fastpathDecMapInt64Uint32R)
 337         fn(map[int64]uint64(nil), (*Encoder).fastpathEncMapInt64Uint64R, (*Decoder).fastpathDecMapInt64Uint64R)
 338         fn(map[int64]uintptr(nil), (*Encoder).fastpathEncMapInt64UintptrR, (*Decoder).fastpathDecMapInt64UintptrR)
 339         fn(map[int64]int(nil), (*Encoder).fastpathEncMapInt64IntR, (*Decoder).fastpathDecMapInt64IntR)
 340         fn(map[int64]int8(nil), (*Encoder).fastpathEncMapInt64Int8R, (*Decoder).fastpathDecMapInt64Int8R)
 341         fn(map[int64]int16(nil), (*Encoder).fastpathEncMapInt64Int16R, (*Decoder).fastpathDecMapInt64Int16R)
 342         fn(map[int64]int32(nil), (*Encoder).fastpathEncMapInt64Int32R, (*Decoder).fastpathDecMapInt64Int32R)
 343         fn(map[int64]int64(nil), (*Encoder).fastpathEncMapInt64Int64R, (*Decoder).fastpathDecMapInt64Int64R)
 344         fn(map[int64]float32(nil), (*Encoder).fastpathEncMapInt64Float32R, (*Decoder).fastpathDecMapInt64Float32R)
 345         fn(map[int64]float64(nil), (*Encoder).fastpathEncMapInt64Float64R, (*Decoder).fastpathDecMapInt64Float64R)
 346         fn(map[int64]bool(nil), (*Encoder).fastpathEncMapInt64BoolR, (*Decoder).fastpathDecMapInt64BoolR)
 347         fn(map[bool]interface{}(nil), (*Encoder).fastpathEncMapBoolIntfR, (*Decoder).fastpathDecMapBoolIntfR)
 348         fn(map[bool]string(nil), (*Encoder).fastpathEncMapBoolStringR, (*Decoder).fastpathDecMapBoolStringR)
 349         fn(map[bool]uint(nil), (*Encoder).fastpathEncMapBoolUintR, (*Decoder).fastpathDecMapBoolUintR)
 350         fn(map[bool]uint8(nil), (*Encoder).fastpathEncMapBoolUint8R, (*Decoder).fastpathDecMapBoolUint8R)
 351         fn(map[bool]uint16(nil), (*Encoder).fastpathEncMapBoolUint16R, (*Decoder).fastpathDecMapBoolUint16R)
 352         fn(map[bool]uint32(nil), (*Encoder).fastpathEncMapBoolUint32R, (*Decoder).fastpathDecMapBoolUint32R)
 353         fn(map[bool]uint64(nil), (*Encoder).fastpathEncMapBoolUint64R, (*Decoder).fastpathDecMapBoolUint64R)
 354         fn(map[bool]uintptr(nil), (*Encoder).fastpathEncMapBoolUintptrR, (*Decoder).fastpathDecMapBoolUintptrR)
 355         fn(map[bool]int(nil), (*Encoder).fastpathEncMapBoolIntR, (*Decoder).fastpathDecMapBoolIntR)
 356         fn(map[bool]int8(nil), (*Encoder).fastpathEncMapBoolInt8R, (*Decoder).fastpathDecMapBoolInt8R)
 357         fn(map[bool]int16(nil), (*Encoder).fastpathEncMapBoolInt16R, (*Decoder).fastpathDecMapBoolInt16R)
 358         fn(map[bool]int32(nil), (*Encoder).fastpathEncMapBoolInt32R, (*Decoder).fastpathDecMapBoolInt32R)
 359         fn(map[bool]int64(nil), (*Encoder).fastpathEncMapBoolInt64R, (*Decoder).fastpathDecMapBoolInt64R)
 360         fn(map[bool]float32(nil), (*Encoder).fastpathEncMapBoolFloat32R, (*Decoder).fastpathDecMapBoolFloat32R)
 361         fn(map[bool]float64(nil), (*Encoder).fastpathEncMapBoolFloat64R, (*Decoder).fastpathDecMapBoolFloat64R)
 362         fn(map[bool]bool(nil), (*Encoder).fastpathEncMapBoolBoolR, (*Decoder).fastpathDecMapBoolBoolR)
 363
 364         sort.Sort(fastpathAslice(fastpathAV[:]))
 365 }
 366
 367 // -- encode
 368
 369 // -- -- fast path type switch
 370 func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool {
 371         switch v := iv.(type) {
 372
 373         case []interface{}:
 374                 fastpathTV.EncSliceIntfV(v, e)
 375         case *[]interface{}:
 376                 fastpathTV.EncSliceIntfV(*v, e)
 377         case []string:
 378                 fastpathTV.EncSliceStringV(v, e)
 379         case *[]string:
 380                 fastpathTV.EncSliceStringV(*v, e)
 381         case []float32:
 382                 fastpathTV.EncSliceFloat32V(v, e)
 383         case *[]float32:
 384                 fastpathTV.EncSliceFloat32V(*v, e)
 385         case []float64:
 386                 fastpathTV.EncSliceFloat64V(v, e)
 387         case *[]float64:
 388                 fastpathTV.EncSliceFloat64V(*v, e)
 389         case []uint:
 390                 fastpathTV.EncSliceUintV(v, e)
 391         case *[]uint:
 392                 fastpathTV.EncSliceUintV(*v, e)
 393         case []uint16:
 394                 fastpathTV.EncSliceUint16V(v, e)
 395         case *[]uint16:
 396                 fastpathTV.EncSliceUint16V(*v, e)
 397         case []uint32:
 398                 fastpathTV.EncSliceUint32V(v, e)
 399         case *[]uint32:
 400                 fastpathTV.EncSliceUint32V(*v, e)
 401         case []uint64:
 402                 fastpathTV.EncSliceUint64V(v, e)
 403         case *[]uint64:
 404                 fastpathTV.EncSliceUint64V(*v, e)
 405         case []uintptr:
 406                 fastpathTV.EncSliceUintptrV(v, e)
 407         case *[]uintptr:
 408                 fastpathTV.EncSliceUintptrV(*v, e)
 409         case []int:
 410                 fastpathTV.EncSliceIntV(v, e)
 411         case *[]int:
 412                 fastpathTV.EncSliceIntV(*v, e)
 413         case []int8:
 414                 fastpathTV.EncSliceInt8V(v, e)
 415         case *[]int8:
 416                 fastpathTV.EncSliceInt8V(*v, e)
 417         case []int16:
 418                 fastpathTV.EncSliceInt16V(v, e)
 419         case *[]int16:
 420                 fastpathTV.EncSliceInt16V(*v, e)
 421         case []int32:
 422                 fastpathTV.EncSliceInt32V(v, e)
 423         case *[]int32:
 424                 fastpathTV.EncSliceInt32V(*v, e)
 425         case []int64:
 426                 fastpathTV.EncSliceInt64V(v, e)
 427         case *[]int64:
 428                 fastpathTV.EncSliceInt64V(*v, e)
 429         case []bool:
 430                 fastpathTV.EncSliceBoolV(v, e)
 431         case *[]bool:
 432                 fastpathTV.EncSliceBoolV(*v, e)
 433
 434         case map[interface{}]interface{}:
 435                 fastpathTV.EncMapIntfIntfV(v, e)
 436         case *map[interface{}]interface{}:
 437                 fastpathTV.EncMapIntfIntfV(*v, e)
 438         case map[interface{}]string:
 439                 fastpathTV.EncMapIntfStringV(v, e)
 440         case *map[interface{}]string:
 441                 fastpathTV.EncMapIntfStringV(*v, e)
 442         case map[interface{}]uint:
 443                 fastpathTV.EncMapIntfUintV(v, e)
 444         case *map[interface{}]uint:
 445                 fastpathTV.EncMapIntfUintV(*v, e)
 446         case map[interface{}]uint8:
 447                 fastpathTV.EncMapIntfUint8V(v, e)
 448         case *map[interface{}]uint8:
 449                 fastpathTV.EncMapIntfUint8V(*v, e)
 450         case map[interface{}]uint16:
 451                 fastpathTV.EncMapIntfUint16V(v, e)
 452         case *map[interface{}]uint16:
 453                 fastpathTV.EncMapIntfUint16V(*v, e)
 454         case map[interface{}]uint32:
 455                 fastpathTV.EncMapIntfUint32V(v, e)
 456         case *map[interface{}]uint32:
 457                 fastpathTV.EncMapIntfUint32V(*v, e)
 458         case map[interface{}]uint64:
 459                 fastpathTV.EncMapIntfUint64V(v, e)
 460         case *map[interface{}]uint64:
 461                 fastpathTV.EncMapIntfUint64V(*v, e)
 462         case map[interface{}]uintptr:
 463                 fastpathTV.EncMapIntfUintptrV(v, e)
 464         case *map[interface{}]uintptr:
 465                 fastpathTV.EncMapIntfUintptrV(*v, e)
 466         case map[interface{}]int:
 467                 fastpathTV.EncMapIntfIntV(v, e)
 468         case *map[interface{}]int:
 469                 fastpathTV.EncMapIntfIntV(*v, e)
 470         case map[interface{}]int8:
 471                 fastpathTV.EncMapIntfInt8V(v, e)
 472         case *map[interface{}]int8:
 473                 fastpathTV.EncMapIntfInt8V(*v, e)
 474         case map[interface{}]int16:
 475                 fastpathTV.EncMapIntfInt16V(v, e)
 476         case *map[interface{}]int16:
 477                 fastpathTV.EncMapIntfInt16V(*v, e)
 478         case map[interface{}]int32:
 479                 fastpathTV.EncMapIntfInt32V(v, e)
 480         case *map[interface{}]int32:
 481                 fastpathTV.EncMapIntfInt32V(*v, e)
 482         case map[interface{}]int64:
 483                 fastpathTV.EncMapIntfInt64V(v, e)
 484         case *map[interface{}]int64:
 485                 fastpathTV.EncMapIntfInt64V(*v, e)
 486         case map[interface{}]float32:
 487                 fastpathTV.EncMapIntfFloat32V(v, e)
 488         case *map[interface{}]float32:
 489                 fastpathTV.EncMapIntfFloat32V(*v, e)
 490         case map[interface{}]float64:
 491                 fastpathTV.EncMapIntfFloat64V(v, e)
 492         case *map[interface{}]float64:
 493                 fastpathTV.EncMapIntfFloat64V(*v, e)
 494         case map[interface{}]bool:
 495                 fastpathTV.EncMapIntfBoolV(v, e)
 496         case *map[interface{}]bool:
 497                 fastpathTV.EncMapIntfBoolV(*v, e)
 498         case map[string]interface{}:
 499                 fastpathTV.EncMapStringIntfV(v, e)
 500         case *map[string]interface{}:
 501                 fastpathTV.EncMapStringIntfV(*v, e)
 502         case map[string]string:
 503                 fastpathTV.EncMapStringStringV(v, e)
 504         case *map[string]string:
 505                 fastpathTV.EncMapStringStringV(*v, e)
 506         case map[string]uint:
 507                 fastpathTV.EncMapStringUintV(v, e)
 508         case *map[string]uint:
 509                 fastpathTV.EncMapStringUintV(*v, e)
 510         case map[string]uint8:
 511                 fastpathTV.EncMapStringUint8V(v, e)
 512         case *map[string]uint8:
 513                 fastpathTV.EncMapStringUint8V(*v, e)
 514         case map[string]uint16:
 515                 fastpathTV.EncMapStringUint16V(v, e)
 516         case *map[string]uint16:
 517                 fastpathTV.EncMapStringUint16V(*v, e)
 518         case map[string]uint32:
 519                 fastpathTV.EncMapStringUint32V(v, e)
 520         case *map[string]uint32:
 521                 fastpathTV.EncMapStringUint32V(*v, e)
 522         case map[string]uint64:
 523                 fastpathTV.EncMapStringUint64V(v, e)
 524         case *map[string]uint64:
 525                 fastpathTV.EncMapStringUint64V(*v, e)
 526         case map[string]uintptr:
 527                 fastpathTV.EncMapStringUintptrV(v, e)
 528         case *map[string]uintptr:
 529                 fastpathTV.EncMapStringUintptrV(*v, e)
 530         case map[string]int:
 531                 fastpathTV.EncMapStringIntV(v, e)
 532         case *map[string]int:
 533                 fastpathTV.EncMapStringIntV(*v, e)
 534         case map[string]int8:
 535                 fastpathTV.EncMapStringInt8V(v, e)
 536         case *map[string]int8:
 537                 fastpathTV.EncMapStringInt8V(*v, e)
 538         case map[string]int16:
 539                 fastpathTV.EncMapStringInt16V(v, e)
 540         case *map[string]int16:
 541                 fastpathTV.EncMapStringInt16V(*v, e)
 542         case map[string]int32:
 543                 fastpathTV.EncMapStringInt32V(v, e)
 544         case *map[string]int32:
 545                 fastpathTV.EncMapStringInt32V(*v, e)
 546         case map[string]int64:
 547                 fastpathTV.EncMapStringInt64V(v, e)
 548         case *map[string]int64:
 549                 fastpathTV.EncMapStringInt64V(*v, e)
 550         case map[string]float32:
 551                 fastpathTV.EncMapStringFloat32V(v, e)
 552         case *map[string]float32:
 553                 fastpathTV.EncMapStringFloat32V(*v, e)
 554         case map[string]float64:
 555                 fastpathTV.EncMapStringFloat64V(v, e)
 556         case *map[string]float64:
 557                 fastpathTV.EncMapStringFloat64V(*v, e)
 558         case map[string]bool:
 559                 fastpathTV.EncMapStringBoolV(v, e)
 560         case *map[string]bool:
 561                 fastpathTV.EncMapStringBoolV(*v, e)
 562         case map[float32]interface{}:
 563                 fastpathTV.EncMapFloat32IntfV(v, e)
 564         case *map[float32]interface{}:
 565                 fastpathTV.EncMapFloat32IntfV(*v, e)
 566         case map[float32]string:
 567                 fastpathTV.EncMapFloat32StringV(v, e)
 568         case *map[float32]string:
 569                 fastpathTV.EncMapFloat32StringV(*v, e)
 570         case map[float32]uint:
 571                 fastpathTV.EncMapFloat32UintV(v, e)
 572         case *map[float32]uint:
 573                 fastpathTV.EncMapFloat32UintV(*v, e)
 574         case map[float32]uint8:
 575                 fastpathTV.EncMapFloat32Uint8V(v, e)
 576         case *map[float32]uint8:
 577                 fastpathTV.EncMapFloat32Uint8V(*v, e)
 578         case map[float32]uint16:
 579                 fastpathTV.EncMapFloat32Uint16V(v, e)
 580         case *map[float32]uint16:
 581                 fastpathTV.EncMapFloat32Uint16V(*v, e)
 582         case map[float32]uint32:
 583                 fastpathTV.EncMapFloat32Uint32V(v, e)
 584         case *map[float32]uint32:
 585                 fastpathTV.EncMapFloat32Uint32V(*v, e)
 586         case map[float32]uint64:
 587                 fastpathTV.EncMapFloat32Uint64V(v, e)
 588         case *map[float32]uint64:
 589                 fastpathTV.EncMapFloat32Uint64V(*v, e)
 590         case map[float32]uintptr:
 591                 fastpathTV.EncMapFloat32UintptrV(v, e)
 592         case *map[float32]uintptr:
 593                 fastpathTV.EncMapFloat32UintptrV(*v, e)
 594         case map[float32]int:
 595                 fastpathTV.EncMapFloat32IntV(v, e)
 596         case *map[float32]int:
 597                 fastpathTV.EncMapFloat32IntV(*v, e)
 598         case map[float32]int8:
 599                 fastpathTV.EncMapFloat32Int8V(v, e)
 600         case *map[float32]int8:
 601                 fastpathTV.EncMapFloat32Int8V(*v, e)
 602         case map[float32]int16:
 603                 fastpathTV.EncMapFloat32Int16V(v, e)
 604         case *map[float32]int16:
 605                 fastpathTV.EncMapFloat32Int16V(*v, e)
 606         case map[float32]int32:
 607                 fastpathTV.EncMapFloat32Int32V(v, e)
 608         case *map[float32]int32:
 609                 fastpathTV.EncMapFloat32Int32V(*v, e)
 610         case map[float32]int64:
 611                 fastpathTV.EncMapFloat32Int64V(v, e)
 612         case *map[float32]int64:
 613                 fastpathTV.EncMapFloat32Int64V(*v, e)
 614         case map[float32]float32:
 615                 fastpathTV.EncMapFloat32Float32V(v, e)
 616         case *map[float32]float32:
 617                 fastpathTV.EncMapFloat32Float32V(*v, e)
 618         case map[float32]float64:
 619                 fastpathTV.EncMapFloat32Float64V(v, e)
 620         case *map[float32]float64:
 621                 fastpathTV.EncMapFloat32Float64V(*v, e)
 622         case map[float32]bool:
 623                 fastpathTV.EncMapFloat32BoolV(v, e)
 624         case *map[float32]bool:
 625                 fastpathTV.EncMapFloat32BoolV(*v, e)
 626         case map[float64]interface{}:
 627                 fastpathTV.EncMapFloat64IntfV(v, e)
 628         case *map[float64]interface{}:
 629                 fastpathTV.EncMapFloat64IntfV(*v, e)
 630         case map[float64]string:
 631                 fastpathTV.EncMapFloat64StringV(v, e)
 632         case *map[float64]string:
 633                 fastpathTV.EncMapFloat64StringV(*v, e)
 634         case map[float64]uint:
 635                 fastpathTV.EncMapFloat64UintV(v, e)
 636         case *map[float64]uint:
 637                 fastpathTV.EncMapFloat64UintV(*v, e)
 638         case map[float64]uint8:
 639                 fastpathTV.EncMapFloat64Uint8V(v, e)
 640         case *map[float64]uint8:
 641                 fastpathTV.EncMapFloat64Uint8V(*v, e)
 642         case map[float64]uint16:
 643                 fastpathTV.EncMapFloat64Uint16V(v, e)
 644         case *map[float64]uint16:
 645                 fastpathTV.EncMapFloat64Uint16V(*v, e)
 646         case map[float64]uint32:
 647                 fastpathTV.EncMapFloat64Uint32V(v, e)
 648         case *map[float64]uint32:
 649                 fastpathTV.EncMapFloat64Uint32V(*v, e)
 650         case map[float64]uint64:
 651                 fastpathTV.EncMapFloat64Uint64V(v, e)
 652         case *map[float64]uint64:
 653                 fastpathTV.EncMapFloat64Uint64V(*v, e)
 654         case map[float64]uintptr:
 655                 fastpathTV.EncMapFloat64UintptrV(v, e)
 656         case *map[float64]uintptr:
 657                 fastpathTV.EncMapFloat64UintptrV(*v, e)
 658         case map[float64]int:
 659                 fastpathTV.EncMapFloat64IntV(v, e)
 660         case *map[float64]int:
 661                 fastpathTV.EncMapFloat64IntV(*v, e)
 662         case map[float64]int8:
 663                 fastpathTV.EncMapFloat64Int8V(v, e)
 664         case *map[float64]int8:
 665                 fastpathTV.EncMapFloat64Int8V(*v, e)
 666         case map[float64]int16:
 667                 fastpathTV.EncMapFloat64Int16V(v, e)
 668         case *map[float64]int16:
 669                 fastpathTV.EncMapFloat64Int16V(*v, e)
 670         case map[float64]int32:
 671                 fastpathTV.EncMapFloat64Int32V(v, e)
 672         case *map[float64]int32:
 673                 fastpathTV.EncMapFloat64Int32V(*v, e)
 674         case map[float64]int64:
 675                 fastpathTV.EncMapFloat64Int64V(v, e)
 676         case *map[float64]int64:
 677                 fastpathTV.EncMapFloat64Int64V(*v, e)
 678         case map[float64]float32:
 679                 fastpathTV.EncMapFloat64Float32V(v, e)
 680         case *map[float64]float32:
 681                 fastpathTV.EncMapFloat64Float32V(*v, e)
 682         case map[float64]float64:
 683                 fastpathTV.EncMapFloat64Float64V(v, e)
 684         case *map[float64]float64:
 685                 fastpathTV.EncMapFloat64Float64V(*v, e)
 686         case map[float64]bool:
 687                 fastpathTV.EncMapFloat64BoolV(v, e)
 688         case *map[float64]bool:
 689                 fastpathTV.EncMapFloat64BoolV(*v, e)
 690         case map[uint]interface{}:
 691                 fastpathTV.EncMapUintIntfV(v, e)
 692         case *map[uint]interface{}:
 693                 fastpathTV.EncMapUintIntfV(*v, e)
 694         case map[uint]string:
 695                 fastpathTV.EncMapUintStringV(v, e)
 696         case *map[uint]string:
 697                 fastpathTV.EncMapUintStringV(*v, e)
 698         case map[uint]uint:
 699                 fastpathTV.EncMapUintUintV(v, e)
 700         case *map[uint]uint:
 701                 fastpathTV.EncMapUintUintV(*v, e)
 702         case map[uint]uint8:
 703                 fastpathTV.EncMapUintUint8V(v, e)
 704         case *map[uint]uint8:
 705                 fastpathTV.EncMapUintUint8V(*v, e)
 706         case map[uint]uint16:
 707                 fastpathTV.EncMapUintUint16V(v, e)
 708         case *map[uint]uint16:
 709                 fastpathTV.EncMapUintUint16V(*v, e)
 710         case map[uint]uint32:
 711                 fastpathTV.EncMapUintUint32V(v, e)
 712         case *map[uint]uint32:
 713                 fastpathTV.EncMapUintUint32V(*v, e)
 714         case map[uint]uint64:
 715                 fastpathTV.EncMapUintUint64V(v, e)
 716         case *map[uint]uint64:
 717                 fastpathTV.EncMapUintUint64V(*v, e)
 718         case map[uint]uintptr:
 719                 fastpathTV.EncMapUintUintptrV(v, e)
 720         case *map[uint]uintptr:
 721                 fastpathTV.EncMapUintUintptrV(*v, e)
 722         case map[uint]int:
 723                 fastpathTV.EncMapUintIntV(v, e)
 724         case *map[uint]int:
 725                 fastpathTV.EncMapUintIntV(*v, e)
 726         case map[uint]int8:
 727                 fastpathTV.EncMapUintInt8V(v, e)
 728         case *map[uint]int8:
 729                 fastpathTV.EncMapUintInt8V(*v, e)
 730         case map[uint]int16:
 731                 fastpathTV.EncMapUintInt16V(v, e)
 732         case *map[uint]int16:
 733                 fastpathTV.EncMapUintInt16V(*v, e)
 734         case map[uint]int32:
 735                 fastpathTV.EncMapUintInt32V(v, e)
 736         case *map[uint]int32:
 737                 fastpathTV.EncMapUintInt32V(*v, e)
 738         case map[uint]int64:
 739                 fastpathTV.EncMapUintInt64V(v, e)
 740         case *map[uint]int64:
 741                 fastpathTV.EncMapUintInt64V(*v, e)
 742         case map[uint]float32:
 743                 fastpathTV.EncMapUintFloat32V(v, e)
 744         case *map[uint]float32:
 745                 fastpathTV.EncMapUintFloat32V(*v, e)
 746         case map[uint]float64:
 747                 fastpathTV.EncMapUintFloat64V(v, e)
 748         case *map[uint]float64:
 749                 fastpathTV.EncMapUintFloat64V(*v, e)
 750         case map[uint]bool:
 751                 fastpathTV.EncMapUintBoolV(v, e)
 752         case *map[uint]bool:
 753                 fastpathTV.EncMapUintBoolV(*v, e)
 754         case map[uint8]interface{}:
 755                 fastpathTV.EncMapUint8IntfV(v, e)
 756         case *map[uint8]interface{}:
 757                 fastpathTV.EncMapUint8IntfV(*v, e)
 758         case map[uint8]string:
 759                 fastpathTV.EncMapUint8StringV(v, e)
 760         case *map[uint8]string:
 761                 fastpathTV.EncMapUint8StringV(*v, e)
 762         case map[uint8]uint:
 763                 fastpathTV.EncMapUint8UintV(v, e)
 764         case *map[uint8]uint:
 765                 fastpathTV.EncMapUint8UintV(*v, e)
 766         case map[uint8]uint8:
 767                 fastpathTV.EncMapUint8Uint8V(v, e)
 768         case *map[uint8]uint8:
 769                 fastpathTV.EncMapUint8Uint8V(*v, e)
 770         case map[uint8]uint16:
 771                 fastpathTV.EncMapUint8Uint16V(v, e)
 772         case *map[uint8]uint16:
 773                 fastpathTV.EncMapUint8Uint16V(*v, e)
 774         case map[uint8]uint32:
 775                 fastpathTV.EncMapUint8Uint32V(v, e)
 776         case *map[uint8]uint32:
 777                 fastpathTV.EncMapUint8Uint32V(*v, e)
 778         case map[uint8]uint64:
 779                 fastpathTV.EncMapUint8Uint64V(v, e)
 780         case *map[uint8]uint64:
 781                 fastpathTV.EncMapUint8Uint64V(*v, e)
 782         case map[uint8]uintptr:
 783                 fastpathTV.EncMapUint8UintptrV(v, e)
 784         case *map[uint8]uintptr:
 785                 fastpathTV.EncMapUint8UintptrV(*v, e)
 786         case map[uint8]int:
 787                 fastpathTV.EncMapUint8IntV(v, e)
 788         case *map[uint8]int:
 789                 fastpathTV.EncMapUint8IntV(*v, e)
 790         case map[uint8]int8:
 791                 fastpathTV.EncMapUint8Int8V(v, e)
 792         case *map[uint8]int8:
 793                 fastpathTV.EncMapUint8Int8V(*v, e)
 794         case map[uint8]int16:
 795                 fastpathTV.EncMapUint8Int16V(v, e)
 796         case *map[uint8]int16:
 797                 fastpathTV.EncMapUint8Int16V(*v, e)
 798         case map[uint8]int32:
 799                 fastpathTV.EncMapUint8Int32V(v, e)
 800         case *map[uint8]int32:
 801                 fastpathTV.EncMapUint8Int32V(*v, e)
 802         case map[uint8]int64:
 803                 fastpathTV.EncMapUint8Int64V(v, e)
 804         case *map[uint8]int64:
 805                 fastpathTV.EncMapUint8Int64V(*v, e)
 806         case map[uint8]float32:
 807                 fastpathTV.EncMapUint8Float32V(v, e)
 808         case *map[uint8]float32:
 809                 fastpathTV.EncMapUint8Float32V(*v, e)
 810         case map[uint8]float64:
 811                 fastpathTV.EncMapUint8Float64V(v, e)
 812         case *map[uint8]float64:
 813                 fastpathTV.EncMapUint8Float64V(*v, e)
 814         case map[uint8]bool:
 815                 fastpathTV.EncMapUint8BoolV(v, e)
 816         case *map[uint8]bool:
 817                 fastpathTV.EncMapUint8BoolV(*v, e)
 818         case map[uint16]interface{}:
 819                 fastpathTV.EncMapUint16IntfV(v, e)
 820         case *map[uint16]interface{}:
 821                 fastpathTV.EncMapUint16IntfV(*v, e)
 822         case map[uint16]string:
 823                 fastpathTV.EncMapUint16StringV(v, e)
 824         case *map[uint16]string:
 825                 fastpathTV.EncMapUint16StringV(*v, e)
 826         case map[uint16]uint:
 827                 fastpathTV.EncMapUint16UintV(v, e)
 828         case *map[uint16]uint:
 829                 fastpathTV.EncMapUint16UintV(*v, e)
 830         case map[uint16]uint8:
 831                 fastpathTV.EncMapUint16Uint8V(v, e)
 832         case *map[uint16]uint8:
 833                 fastpathTV.EncMapUint16Uint8V(*v, e)
 834         case map[uint16]uint16:
 835                 fastpathTV.EncMapUint16Uint16V(v, e)
 836         case *map[uint16]uint16:
 837                 fastpathTV.EncMapUint16Uint16V(*v, e)
 838         case map[uint16]uint32:
 839                 fastpathTV.EncMapUint16Uint32V(v, e)
 840         case *map[uint16]uint32:
 841                 fastpathTV.EncMapUint16Uint32V(*v, e)
 842         case map[uint16]uint64:
 843                 fastpathTV.EncMapUint16Uint64V(v, e)
 844         case *map[uint16]uint64:
 845                 fastpathTV.EncMapUint16Uint64V(*v, e)
 846         case map[uint16]uintptr:
 847                 fastpathTV.EncMapUint16UintptrV(v, e)
 848         case *map[uint16]uintptr:
 849                 fastpathTV.EncMapUint16UintptrV(*v, e)
 850         case map[uint16]int:
 851                 fastpathTV.EncMapUint16IntV(v, e)
 852         case *map[uint16]int:
 853                 fastpathTV.EncMapUint16IntV(*v, e)
 854         case map[uint16]int8:
 855                 fastpathTV.EncMapUint16Int8V(v, e)
 856         case *map[uint16]int8:
 857                 fastpathTV.EncMapUint16Int8V(*v, e)
 858         case map[uint16]int16:
 859                 fastpathTV.EncMapUint16Int16V(v, e)
 860         case *map[uint16]int16:
 861                 fastpathTV.EncMapUint16Int16V(*v, e)
 862         case map[uint16]int32:
 863                 fastpathTV.EncMapUint16Int32V(v, e)
 864         case *map[uint16]int32:
 865                 fastpathTV.EncMapUint16Int32V(*v, e)
 866         case map[uint16]int64:
 867                 fastpathTV.EncMapUint16Int64V(v, e)
 868         case *map[uint16]int64:
 869                 fastpathTV.EncMapUint16Int64V(*v, e)
 870         case map[uint16]float32:
 871                 fastpathTV.EncMapUint16Float32V(v, e)
 872         case *map[uint16]float32:
 873                 fastpathTV.EncMapUint16Float32V(*v, e)
 874         case map[uint16]float64:
 875                 fastpathTV.EncMapUint16Float64V(v, e)
 876         case *map[uint16]float64:
 877                 fastpathTV.EncMapUint16Float64V(*v, e)
 878         case map[uint16]bool:
 879                 fastpathTV.EncMapUint16BoolV(v, e)
 880         case *map[uint16]bool:
 881                 fastpathTV.EncMapUint16BoolV(*v, e)
 882         case map[uint32]interface{}:
 883                 fastpathTV.EncMapUint32IntfV(v, e)
 884         case *map[uint32]interface{}:
 885                 fastpathTV.EncMapUint32IntfV(*v, e)
 886         case map[uint32]string:
 887                 fastpathTV.EncMapUint32StringV(v, e)
 888         case *map[uint32]string:
 889                 fastpathTV.EncMapUint32StringV(*v, e)
 890         case map[uint32]uint:
 891                 fastpathTV.EncMapUint32UintV(v, e)
 892         case *map[uint32]uint:
 893                 fastpathTV.EncMapUint32UintV(*v, e)
 894         case map[uint32]uint8:
 895                 fastpathTV.EncMapUint32Uint8V(v, e)
 896         case *map[uint32]uint8:
 897                 fastpathTV.EncMapUint32Uint8V(*v, e)
 898         case map[uint32]uint16:
 899                 fastpathTV.EncMapUint32Uint16V(v, e)
 900         case *map[uint32]uint16:
 901                 fastpathTV.EncMapUint32Uint16V(*v, e)
 902         case map[uint32]uint32:
 903                 fastpathTV.EncMapUint32Uint32V(v, e)
 904         case *map[uint32]uint32:
 905                 fastpathTV.EncMapUint32Uint32V(*v, e)
 906         case map[uint32]uint64:
 907                 fastpathTV.EncMapUint32Uint64V(v, e)
 908         case *map[uint32]uint64:
 909                 fastpathTV.EncMapUint32Uint64V(*v, e)
 910         case map[uint32]uintptr:
 911                 fastpathTV.EncMapUint32UintptrV(v, e)
 912         case *map[uint32]uintptr:
 913                 fastpathTV.EncMapUint32UintptrV(*v, e)
 914         case map[uint32]int:
 915                 fastpathTV.EncMapUint32IntV(v, e)
 916         case *map[uint32]int:
 917                 fastpathTV.EncMapUint32IntV(*v, e)
 918         case map[uint32]int8:
 919                 fastpathTV.EncMapUint32Int8V(v, e)
 920         case *map[uint32]int8:
 921                 fastpathTV.EncMapUint32Int8V(*v, e)
 922         case map[uint32]int16:
 923                 fastpathTV.EncMapUint32Int16V(v, e)
 924         case *map[uint32]int16:
 925                 fastpathTV.EncMapUint32Int16V(*v, e)
 926         case map[uint32]int32:
 927                 fastpathTV.EncMapUint32Int32V(v, e)
 928         case *map[uint32]int32:
 929                 fastpathTV.EncMapUint32Int32V(*v, e)
 930         case map[uint32]int64:
 931                 fastpathTV.EncMapUint32Int64V(v, e)
 932         case *map[uint32]int64:
 933                 fastpathTV.EncMapUint32Int64V(*v, e)
 934         case map[uint32]float32:
 935                 fastpathTV.EncMapUint32Float32V(v, e)
 936         case *map[uint32]float32:
 937                 fastpathTV.EncMapUint32Float32V(*v, e)
 938         case map[uint32]float64:
 939                 fastpathTV.EncMapUint32Float64V(v, e)
 940         case *map[uint32]float64:
 941                 fastpathTV.EncMapUint32Float64V(*v, e)
 942         case map[uint32]bool:
 943                 fastpathTV.EncMapUint32BoolV(v, e)
 944         case *map[uint32]bool:
 945                 fastpathTV.EncMapUint32BoolV(*v, e)
 946         case map[uint64]interface{}:
 947                 fastpathTV.EncMapUint64IntfV(v, e)
 948         case *map[uint64]interface{}:
 949                 fastpathTV.EncMapUint64IntfV(*v, e)
 950         case map[uint64]string:
 951                 fastpathTV.EncMapUint64StringV(v, e)
 952         case *map[uint64]string:
 953                 fastpathTV.EncMapUint64StringV(*v, e)
 954         case map[uint64]uint:
 955                 fastpathTV.EncMapUint64UintV(v, e)
 956         case *map[uint64]uint:
 957                 fastpathTV.EncMapUint64UintV(*v, e)
 958         case map[uint64]uint8:
 959                 fastpathTV.EncMapUint64Uint8V(v, e)
 960         case *map[uint64]uint8:
 961                 fastpathTV.EncMapUint64Uint8V(*v, e)
 962         case map[uint64]uint16:
 963                 fastpathTV.EncMapUint64Uint16V(v, e)
 964         case *map[uint64]uint16:
 965                 fastpathTV.EncMapUint64Uint16V(*v, e)
 966         case map[uint64]uint32:
 967                 fastpathTV.EncMapUint64Uint32V(v, e)
 968         case *map[uint64]uint32:
 969                 fastpathTV.EncMapUint64Uint32V(*v, e)
 970         case map[uint64]uint64:
 971                 fastpathTV.EncMapUint64Uint64V(v, e)
 972         case *map[uint64]uint64:
 973                 fastpathTV.EncMapUint64Uint64V(*v, e)
 974         case map[uint64]uintptr:
 975                 fastpathTV.EncMapUint64UintptrV(v, e)
 976         case *map[uint64]uintptr:
 977                 fastpathTV.EncMapUint64UintptrV(*v, e)
 978         case map[uint64]int:
 979                 fastpathTV.EncMapUint64IntV(v, e)
 980         case *map[uint64]int:
 981                 fastpathTV.EncMapUint64IntV(*v, e)
 982         case map[uint64]int8:
 983                 fastpathTV.EncMapUint64Int8V(v, e)
 984         case *map[uint64]int8:
 985                 fastpathTV.EncMapUint64Int8V(*v, e)
 986         case map[uint64]int16:
 987                 fastpathTV.EncMapUint64Int16V(v, e)
 988         case *map[uint64]int16:
 989                 fastpathTV.EncMapUint64Int16V(*v, e)
 990         case map[uint64]int32:
 991                 fastpathTV.EncMapUint64Int32V(v, e)
 992         case *map[uint64]int32:
 993                 fastpathTV.EncMapUint64Int32V(*v, e)
 994         case map[uint64]int64:
 995                 fastpathTV.EncMapUint64Int64V(v, e)
 996         case *map[uint64]int64:
 997                 fastpathTV.EncMapUint64Int64V(*v, e)
 998         case map[uint64]float32:
 999                 fastpathTV.EncMapUint64Float32V(v, e)
1000         case *map[uint64]float32:
1001                 fastpathTV.EncMapUint64Float32V(*v, e)
1002         case map[uint64]float64:
1003                 fastpathTV.EncMapUint64Float64V(v, e)
1004         case *map[uint64]float64:
1005                 fastpathTV.EncMapUint64Float64V(*v, e)
1006         case map[uint64]bool:
1007                 fastpathTV.EncMapUint64BoolV(v, e)
1008         case *map[uint64]bool:
1009                 fastpathTV.EncMapUint64BoolV(*v, e)
1010         case map[uintptr]interface{}:
1011                 fastpathTV.EncMapUintptrIntfV(v, e)
1012         case *map[uintptr]interface{}:
1013                 fastpathTV.EncMapUintptrIntfV(*v, e)
1014         case map[uintptr]string:
1015                 fastpathTV.EncMapUintptrStringV(v, e)
1016         case *map[uintptr]string:
1017                 fastpathTV.EncMapUintptrStringV(*v, e)
1018         case map[uintptr]uint:
1019                 fastpathTV.EncMapUintptrUintV(v, e)
1020         case *map[uintptr]uint:
1021                 fastpathTV.EncMapUintptrUintV(*v, e)
1022         case map[uintptr]uint8:
1023                 fastpathTV.EncMapUintptrUint8V(v, e)
1024         case *map[uintptr]uint8:
1025                 fastpathTV.EncMapUintptrUint8V(*v, e)
1026         case map[uintptr]uint16:
1027                 fastpathTV.EncMapUintptrUint16V(v, e)
1028         case *map[uintptr]uint16:
1029                 fastpathTV.EncMapUintptrUint16V(*v, e)
1030         case map[uintptr]uint32:
1031                 fastpathTV.EncMapUintptrUint32V(v, e)
1032         case *map[uintptr]uint32:
1033                 fastpathTV.EncMapUintptrUint32V(*v, e)
1034         case map[uintptr]uint64:
1035                 fastpathTV.EncMapUintptrUint64V(v, e)
1036         case *map[uintptr]uint64:
1037                 fastpathTV.EncMapUintptrUint64V(*v, e)
1038         case map[uintptr]uintptr:
1039                 fastpathTV.EncMapUintptrUintptrV(v, e)
1040         case *map[uintptr]uintptr:
1041                 fastpathTV.EncMapUintptrUintptrV(*v, e)
1042         case map[uintptr]int:
1043                 fastpathTV.EncMapUintptrIntV(v, e)
1044         case *map[uintptr]int:
1045                 fastpathTV.EncMapUintptrIntV(*v, e)
1046         case map[uintptr]int8:
1047                 fastpathTV.EncMapUintptrInt8V(v, e)
1048         case *map[uintptr]int8:
1049                 fastpathTV.EncMapUintptrInt8V(*v, e)
1050         case map[uintptr]int16:
1051                 fastpathTV.EncMapUintptrInt16V(v, e)
1052         case *map[uintptr]int16:
1053                 fastpathTV.EncMapUintptrInt16V(*v, e)
1054         case map[uintptr]int32:
1055                 fastpathTV.EncMapUintptrInt32V(v, e)
1056         case *map[uintptr]int32:
1057                 fastpathTV.EncMapUintptrInt32V(*v, e)
1058         case map[uintptr]int64:
1059                 fastpathTV.EncMapUintptrInt64V(v, e)
1060         case *map[uintptr]int64:
1061                 fastpathTV.EncMapUintptrInt64V(*v, e)
1062         case map[uintptr]float32:
1063                 fastpathTV.EncMapUintptrFloat32V(v, e)
1064         case *map[uintptr]float32:
1065                 fastpathTV.EncMapUintptrFloat32V(*v, e)
1066         case map[uintptr]float64:
1067                 fastpathTV.EncMapUintptrFloat64V(v, e)
1068         case *map[uintptr]float64:
1069                 fastpathTV.EncMapUintptrFloat64V(*v, e)
1070         case map[uintptr]bool:
1071                 fastpathTV.EncMapUintptrBoolV(v, e)
1072         case *map[uintptr]bool:
1073                 fastpathTV.EncMapUintptrBoolV(*v, e)
1074         case map[int]interface{}:
1075                 fastpathTV.EncMapIntIntfV(v, e)
1076         case *map[int]interface{}:
1077                 fastpathTV.EncMapIntIntfV(*v, e)
1078         case map[int]string:
1079                 fastpathTV.EncMapIntStringV(v, e)
1080         case *map[int]string:
1081                 fastpathTV.EncMapIntStringV(*v, e)
1082         case map[int]uint:
1083                 fastpathTV.EncMapIntUintV(v, e)
1084         case *map[int]uint:
1085                 fastpathTV.EncMapIntUintV(*v, e)
1086         case map[int]uint8:
1087                 fastpathTV.EncMapIntUint8V(v, e)
1088         case *map[int]uint8:
1089                 fastpathTV.EncMapIntUint8V(*v, e)
1090         case map[int]uint16:
1091                 fastpathTV.EncMapIntUint16V(v, e)
1092         case *map[int]uint16:
1093                 fastpathTV.EncMapIntUint16V(*v, e)
1094         case map[int]uint32:
1095                 fastpathTV.EncMapIntUint32V(v, e)
1096         case *map[int]uint32:
1097                 fastpathTV.EncMapIntUint32V(*v, e)
1098         case map[int]uint64:
1099                 fastpathTV.EncMapIntUint64V(v, e)
1100         case *map[int]uint64:
1101                 fastpathTV.EncMapIntUint64V(*v, e)
1102         case map[int]uintptr:
1103                 fastpathTV.EncMapIntUintptrV(v, e)
1104         case *map[int]uintptr:
1105                 fastpathTV.EncMapIntUintptrV(*v, e)
1106         case map[int]int:
1107                 fastpathTV.EncMapIntIntV(v, e)
1108         case *map[int]int:
1109                 fastpathTV.EncMapIntIntV(*v, e)
1110         case map[int]int8:
1111                 fastpathTV.EncMapIntInt8V(v, e)
1112         case *map[int]int8:
1113                 fastpathTV.EncMapIntInt8V(*v, e)
1114         case map[int]int16:
1115                 fastpathTV.EncMapIntInt16V(v, e)
1116         case *map[int]int16:
1117                 fastpathTV.EncMapIntInt16V(*v, e)
1118         case map[int]int32:
1119                 fastpathTV.EncMapIntInt32V(v, e)
1120         case *map[int]int32:
1121                 fastpathTV.EncMapIntInt32V(*v, e)
1122         case map[int]int64:
1123                 fastpathTV.EncMapIntInt64V(v, e)
1124         case *map[int]int64:
1125                 fastpathTV.EncMapIntInt64V(*v, e)
1126         case map[int]float32:
1127                 fastpathTV.EncMapIntFloat32V(v, e)
1128         case *map[int]float32:
1129                 fastpathTV.EncMapIntFloat32V(*v, e)
1130         case map[int]float64:
1131                 fastpathTV.EncMapIntFloat64V(v, e)
1132         case *map[int]float64:
1133                 fastpathTV.EncMapIntFloat64V(*v, e)
1134         case map[int]bool:
1135                 fastpathTV.EncMapIntBoolV(v, e)
1136         case *map[int]bool:
1137                 fastpathTV.EncMapIntBoolV(*v, e)
1138         case map[int8]interface{}:
1139                 fastpathTV.EncMapInt8IntfV(v, e)
1140         case *map[int8]interface{}:
1141                 fastpathTV.EncMapInt8IntfV(*v, e)
1142         case map[int8]string:
1143                 fastpathTV.EncMapInt8StringV(v, e)
1144         case *map[int8]string:
1145                 fastpathTV.EncMapInt8StringV(*v, e)
1146         case map[int8]uint:
1147                 fastpathTV.EncMapInt8UintV(v, e)
1148         case *map[int8]uint:
1149                 fastpathTV.EncMapInt8UintV(*v, e)
1150         case map[int8]uint8:
1151                 fastpathTV.EncMapInt8Uint8V(v, e)
1152         case *map[int8]uint8:
1153                 fastpathTV.EncMapInt8Uint8V(*v, e)
1154         case map[int8]uint16:
1155                 fastpathTV.EncMapInt8Uint16V(v, e)
1156         case *map[int8]uint16:
1157                 fastpathTV.EncMapInt8Uint16V(*v, e)
1158         case map[int8]uint32:
1159                 fastpathTV.EncMapInt8Uint32V(v, e)
1160         case *map[int8]uint32:
1161                 fastpathTV.EncMapInt8Uint32V(*v, e)
1162         case map[int8]uint64:
1163                 fastpathTV.EncMapInt8Uint64V(v, e)
1164         case *map[int8]uint64:
1165                 fastpathTV.EncMapInt8Uint64V(*v, e)
1166         case map[int8]uintptr:
1167                 fastpathTV.EncMapInt8UintptrV(v, e)
1168         case *map[int8]uintptr:
1169                 fastpathTV.EncMapInt8UintptrV(*v, e)
1170         case map[int8]int:
1171                 fastpathTV.EncMapInt8IntV(v, e)
1172         case *map[int8]int:
1173                 fastpathTV.EncMapInt8IntV(*v, e)
1174         case map[int8]int8:
1175                 fastpathTV.EncMapInt8Int8V(v, e)
1176         case *map[int8]int8:
1177                 fastpathTV.EncMapInt8Int8V(*v, e)
1178         case map[int8]int16:
1179                 fastpathTV.EncMapInt8Int16V(v, e)
1180         case *map[int8]int16:
1181                 fastpathTV.EncMapInt8Int16V(*v, e)
1182         case map[int8]int32:
1183                 fastpathTV.EncMapInt8Int32V(v, e)
1184         case *map[int8]int32:
1185                 fastpathTV.EncMapInt8Int32V(*v, e)
1186         case map[int8]int64:
1187                 fastpathTV.EncMapInt8Int64V(v, e)
1188         case *map[int8]int64:
1189                 fastpathTV.EncMapInt8Int64V(*v, e)
1190         case map[int8]float32:
1191                 fastpathTV.EncMapInt8Float32V(v, e)
1192         case *map[int8]float32:
1193                 fastpathTV.EncMapInt8Float32V(*v, e)
1194         case map[int8]float64:
1195                 fastpathTV.EncMapInt8Float64V(v, e)
1196         case *map[int8]float64:
1197                 fastpathTV.EncMapInt8Float64V(*v, e)
1198         case map[int8]bool:
1199                 fastpathTV.EncMapInt8BoolV(v, e)
1200         case *map[int8]bool:
1201                 fastpathTV.EncMapInt8BoolV(*v, e)
1202         case map[int16]interface{}:
1203                 fastpathTV.EncMapInt16IntfV(v, e)
1204         case *map[int16]interface{}:
1205                 fastpathTV.EncMapInt16IntfV(*v, e)
1206         case map[int16]string:
1207                 fastpathTV.EncMapInt16StringV(v, e)
1208         case *map[int16]string:
1209                 fastpathTV.EncMapInt16StringV(*v, e)
1210         case map[int16]uint:
1211                 fastpathTV.EncMapInt16UintV(v, e)
1212         case *map[int16]uint:
1213                 fastpathTV.EncMapInt16UintV(*v, e)
1214         case map[int16]uint8:
1215                 fastpathTV.EncMapInt16Uint8V(v, e)
1216         case *map[int16]uint8:
1217                 fastpathTV.EncMapInt16Uint8V(*v, e)
1218         case map[int16]uint16:
1219                 fastpathTV.EncMapInt16Uint16V(v, e)
1220         case *map[int16]uint16:
1221                 fastpathTV.EncMapInt16Uint16V(*v, e)
1222         case map[int16]uint32:
1223                 fastpathTV.EncMapInt16Uint32V(v, e)
1224         case *map[int16]uint32:
1225                 fastpathTV.EncMapInt16Uint32V(*v, e)
1226         case map[int16]uint64:
1227                 fastpathTV.EncMapInt16Uint64V(v, e)
1228         case *map[int16]uint64:
1229                 fastpathTV.EncMapInt16Uint64V(*v, e)
1230         case map[int16]uintptr:
1231                 fastpathTV.EncMapInt16UintptrV(v, e)
1232         case *map[int16]uintptr:
1233                 fastpathTV.EncMapInt16UintptrV(*v, e)
1234         case map[int16]int:
1235                 fastpathTV.EncMapInt16IntV(v, e)
1236         case *map[int16]int:
1237                 fastpathTV.EncMapInt16IntV(*v, e)
1238         case map[int16]int8:
1239                 fastpathTV.EncMapInt16Int8V(v, e)
1240         case *map[int16]int8:
1241                 fastpathTV.EncMapInt16Int8V(*v, e)
1242         case map[int16]int16:
1243                 fastpathTV.EncMapInt16Int16V(v, e)
1244         case *map[int16]int16:
1245                 fastpathTV.EncMapInt16Int16V(*v, e)
1246         case map[int16]int32:
1247                 fastpathTV.EncMapInt16Int32V(v, e)
1248         case *map[int16]int32:
1249                 fastpathTV.EncMapInt16Int32V(*v, e)
1250         case map[int16]int64:
1251                 fastpathTV.EncMapInt16Int64V(v, e)
1252         case *map[int16]int64:
1253                 fastpathTV.EncMapInt16Int64V(*v, e)
1254         case map[int16]float32:
1255                 fastpathTV.EncMapInt16Float32V(v, e)
1256         case *map[int16]float32:
1257                 fastpathTV.EncMapInt16Float32V(*v, e)
1258         case map[int16]float64:
1259                 fastpathTV.EncMapInt16Float64V(v, e)
1260         case *map[int16]float64:
1261                 fastpathTV.EncMapInt16Float64V(*v, e)
1262         case map[int16]bool:
1263                 fastpathTV.EncMapInt16BoolV(v, e)
1264         case *map[int16]bool:
1265                 fastpathTV.EncMapInt16BoolV(*v, e)
1266         case map[int32]interface{}:
1267                 fastpathTV.EncMapInt32IntfV(v, e)
1268         case *map[int32]interface{}:
1269                 fastpathTV.EncMapInt32IntfV(*v, e)
1270         case map[int32]string:
1271                 fastpathTV.EncMapInt32StringV(v, e)
1272         case *map[int32]string:
1273                 fastpathTV.EncMapInt32StringV(*v, e)
1274         case map[int32]uint:
1275                 fastpathTV.EncMapInt32UintV(v, e)
1276         case *map[int32]uint:
1277                 fastpathTV.EncMapInt32UintV(*v, e)
1278         case map[int32]uint8:
1279                 fastpathTV.EncMapInt32Uint8V(v, e)
1280         case *map[int32]uint8:
1281                 fastpathTV.EncMapInt32Uint8V(*v, e)
1282         case map[int32]uint16:
1283                 fastpathTV.EncMapInt32Uint16V(v, e)
1284         case *map[int32]uint16:
1285                 fastpathTV.EncMapInt32Uint16V(*v, e)
1286         case map[int32]uint32:
1287                 fastpathTV.EncMapInt32Uint32V(v, e)
1288         case *map[int32]uint32:
1289                 fastpathTV.EncMapInt32Uint32V(*v, e)
1290         case map[int32]uint64:
1291                 fastpathTV.EncMapInt32Uint64V(v, e)
1292         case *map[int32]uint64:
1293                 fastpathTV.EncMapInt32Uint64V(*v, e)
1294         case map[int32]uintptr:
1295                 fastpathTV.EncMapInt32UintptrV(v, e)
1296         case *map[int32]uintptr:
1297                 fastpathTV.EncMapInt32UintptrV(*v, e)
1298         case map[int32]int:
1299                 fastpathTV.EncMapInt32IntV(v, e)
1300         case *map[int32]int:
1301                 fastpathTV.EncMapInt32IntV(*v, e)
1302         case map[int32]int8:
1303                 fastpathTV.EncMapInt32Int8V(v, e)
1304         case *map[int32]int8:
1305                 fastpathTV.EncMapInt32Int8V(*v, e)
1306         case map[int32]int16:
1307                 fastpathTV.EncMapInt32Int16V(v, e)
1308         case *map[int32]int16:
1309                 fastpathTV.EncMapInt32Int16V(*v, e)
1310         case map[int32]int32:
1311                 fastpathTV.EncMapInt32Int32V(v, e)
1312         case *map[int32]int32:
1313                 fastpathTV.EncMapInt32Int32V(*v, e)
1314         case map[int32]int64:
1315                 fastpathTV.EncMapInt32Int64V(v, e)
1316         case *map[int32]int64:
1317                 fastpathTV.EncMapInt32Int64V(*v, e)
1318         case map[int32]float32:
1319                 fastpathTV.EncMapInt32Float32V(v, e)
1320         case *map[int32]float32:
1321                 fastpathTV.EncMapInt32Float32V(*v, e)
1322         case map[int32]float64:
1323                 fastpathTV.EncMapInt32Float64V(v, e)
1324         case *map[int32]float64:
1325                 fastpathTV.EncMapInt32Float64V(*v, e)
1326         case map[int32]bool:
1327                 fastpathTV.EncMapInt32BoolV(v, e)
1328         case *map[int32]bool:
1329                 fastpathTV.EncMapInt32BoolV(*v, e)
1330         case map[int64]interface{}:
1331                 fastpathTV.EncMapInt64IntfV(v, e)
1332         case *map[int64]interface{}:
1333                 fastpathTV.EncMapInt64IntfV(*v, e)
1334         case map[int64]string:
1335                 fastpathTV.EncMapInt64StringV(v, e)
1336         case *map[int64]string:
1337                 fastpathTV.EncMapInt64StringV(*v, e)
1338         case map[int64]uint:
1339                 fastpathTV.EncMapInt64UintV(v, e)
1340         case *map[int64]uint:
1341                 fastpathTV.EncMapInt64UintV(*v, e)
1342         case map[int64]uint8:
1343                 fastpathTV.EncMapInt64Uint8V(v, e)
1344         case *map[int64]uint8:
1345                 fastpathTV.EncMapInt64Uint8V(*v, e)
1346         case map[int64]uint16:
1347                 fastpathTV.EncMapInt64Uint16V(v, e)
1348         case *map[int64]uint16:
1349                 fastpathTV.EncMapInt64Uint16V(*v, e)
1350         case map[int64]uint32:
1351                 fastpathTV.EncMapInt64Uint32V(v, e)
1352         case *map[int64]uint32:
1353                 fastpathTV.EncMapInt64Uint32V(*v, e)
1354         case map[int64]uint64:
1355                 fastpathTV.EncMapInt64Uint64V(v, e)
1356         case *map[int64]uint64:
1357                 fastpathTV.EncMapInt64Uint64V(*v, e)
1358         case map[int64]uintptr:
1359                 fastpathTV.EncMapInt64UintptrV(v, e)
1360         case *map[int64]uintptr:
1361                 fastpathTV.EncMapInt64UintptrV(*v, e)
1362         case map[int64]int:
1363                 fastpathTV.EncMapInt64IntV(v, e)
1364         case *map[int64]int:
1365                 fastpathTV.EncMapInt64IntV(*v, e)
1366         case map[int64]int8:
1367                 fastpathTV.EncMapInt64Int8V(v, e)
1368         case *map[int64]int8:
1369                 fastpathTV.EncMapInt64Int8V(*v, e)
1370         case map[int64]int16:
1371                 fastpathTV.EncMapInt64Int16V(v, e)
1372         case *map[int64]int16:
1373                 fastpathTV.EncMapInt64Int16V(*v, e)
1374         case map[int64]int32:
1375                 fastpathTV.EncMapInt64Int32V(v, e)
1376         case *map[int64]int32:
1377                 fastpathTV.EncMapInt64Int32V(*v, e)
1378         case map[int64]int64:
1379                 fastpathTV.EncMapInt64Int64V(v, e)
1380         case *map[int64]int64:
1381                 fastpathTV.EncMapInt64Int64V(*v, e)
1382         case map[int64]float32:
1383                 fastpathTV.EncMapInt64Float32V(v, e)
1384         case *map[int64]float32:
1385                 fastpathTV.EncMapInt64Float32V(*v, e)
1386         case map[int64]float64:
1387                 fastpathTV.EncMapInt64Float64V(v, e)
1388         case *map[int64]float64:
1389                 fastpathTV.EncMapInt64Float64V(*v, e)
1390         case map[int64]bool:
1391                 fastpathTV.EncMapInt64BoolV(v, e)
1392         case *map[int64]bool:
1393                 fastpathTV.EncMapInt64BoolV(*v, e)
1394         case map[bool]interface{}:
1395                 fastpathTV.EncMapBoolIntfV(v, e)
1396         case *map[bool]interface{}:
1397                 fastpathTV.EncMapBoolIntfV(*v, e)
1398         case map[bool]string:
1399                 fastpathTV.EncMapBoolStringV(v, e)
1400         case *map[bool]string:
1401                 fastpathTV.EncMapBoolStringV(*v, e)
1402         case map[bool]uint:
1403                 fastpathTV.EncMapBoolUintV(v, e)
1404         case *map[bool]uint:
1405                 fastpathTV.EncMapBoolUintV(*v, e)
1406         case map[bool]uint8:
1407                 fastpathTV.EncMapBoolUint8V(v, e)
1408         case *map[bool]uint8:
1409                 fastpathTV.EncMapBoolUint8V(*v, e)
1410         case map[bool]uint16:
1411                 fastpathTV.EncMapBoolUint16V(v, e)
1412         case *map[bool]uint16:
1413                 fastpathTV.EncMapBoolUint16V(*v, e)
1414         case map[bool]uint32:
1415                 fastpathTV.EncMapBoolUint32V(v, e)
1416         case *map[bool]uint32:
1417                 fastpathTV.EncMapBoolUint32V(*v, e)
1418         case map[bool]uint64:
1419                 fastpathTV.EncMapBoolUint64V(v, e)
1420         case *map[bool]uint64:
1421                 fastpathTV.EncMapBoolUint64V(*v, e)
1422         case map[bool]uintptr:
1423                 fastpathTV.EncMapBoolUintptrV(v, e)
1424         case *map[bool]uintptr:
1425                 fastpathTV.EncMapBoolUintptrV(*v, e)
1426         case map[bool]int:
1427                 fastpathTV.EncMapBoolIntV(v, e)
1428         case *map[bool]int:
1429                 fastpathTV.EncMapBoolIntV(*v, e)
1430         case map[bool]int8:
1431                 fastpathTV.EncMapBoolInt8V(v, e)
1432         case *map[bool]int8:
1433                 fastpathTV.EncMapBoolInt8V(*v, e)
1434         case map[bool]int16:
1435                 fastpathTV.EncMapBoolInt16V(v, e)
1436         case *map[bool]int16:
1437                 fastpathTV.EncMapBoolInt16V(*v, e)
1438         case map[bool]int32:
1439                 fastpathTV.EncMapBoolInt32V(v, e)
1440         case *map[bool]int32:
1441                 fastpathTV.EncMapBoolInt32V(*v, e)
1442         case map[bool]int64:
1443                 fastpathTV.EncMapBoolInt64V(v, e)
1444         case *map[bool]int64:
1445                 fastpathTV.EncMapBoolInt64V(*v, e)
1446         case map[bool]float32:
1447                 fastpathTV.EncMapBoolFloat32V(v, e)
1448         case *map[bool]float32:
1449                 fastpathTV.EncMapBoolFloat32V(*v, e)
1450         case map[bool]float64:
1451                 fastpathTV.EncMapBoolFloat64V(v, e)
1452         case *map[bool]float64:
1453                 fastpathTV.EncMapBoolFloat64V(*v, e)
1454         case map[bool]bool:
1455                 fastpathTV.EncMapBoolBoolV(v, e)
1456         case *map[bool]bool:
1457                 fastpathTV.EncMapBoolBoolV(*v, e)
1458
1459         default:
1460                 _ = v // workaround https://github.com/golang/go/issues/12927 seen in go1.4
1461                 return false
1462         }
1463         return true
1464 }
1465
1466 // -- -- fast path functions
1467
1468 func (e *Encoder) fastpathEncSliceIntfR(f *codecFnInfo, rv reflect.Value) {
1469         if f.ti.mbs {
1470                 fastpathTV.EncAsMapSliceIntfV(rv2i(rv).([]interface{}), e)
1471         } else {
1472                 fastpathTV.EncSliceIntfV(rv2i(rv).([]interface{}), e)
1473         }
1474 }
1475 func (_ fastpathT) EncSliceIntfV(v []interface{}, e *Encoder) {
1476         if v == nil {
1477                 e.e.EncodeNil()
1478                 return
1479         }
1480         ee, esep := e.e, e.hh.hasElemSeparators()
1481         ee.WriteArrayStart(len(v))
1482         if esep {
1483                 for _, v2 := range v {
1484                         ee.WriteArrayElem()
1485                         e.encode(v2)
1486                 }
1487         } else {
1488                 for _, v2 := range v {
1489                         e.encode(v2)
1490                 }
1491         }
1492         ee.WriteArrayEnd()
1493 }
1494 func (_ fastpathT) EncAsMapSliceIntfV(v []interface{}, e *Encoder) {
1495         ee, esep := e.e, e.hh.hasElemSeparators()
1496         if len(v)%2 == 1 {
1497                 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
1498                 return
1499         }
1500         ee.WriteMapStart(len(v) / 2)
1501         if esep {
1502                 for j, v2 := range v {
1503                         if j%2 == 0 {
1504                                 ee.WriteMapElemKey()
1505                         } else {
1506                                 ee.WriteMapElemValue()
1507                         }
1508                         e.encode(v2)
1509                 }
1510         } else {
1511                 for _, v2 := range v {
1512                         e.encode(v2)
1513                 }
1514         }
1515         ee.WriteMapEnd()
1516 }
1517
1518 func (e *Encoder) fastpathEncSliceStringR(f *codecFnInfo, rv reflect.Value) {
1519         if f.ti.mbs {
1520                 fastpathTV.EncAsMapSliceStringV(rv2i(rv).([]string), e)
1521         } else {
1522                 fastpathTV.EncSliceStringV(rv2i(rv).([]string), e)
1523         }
1524 }
1525 func (_ fastpathT) EncSliceStringV(v []string, e *Encoder) {
1526         if v == nil {
1527                 e.e.EncodeNil()
1528                 return
1529         }
1530         ee, esep := e.e, e.hh.hasElemSeparators()
1531         ee.WriteArrayStart(len(v))
1532         if esep {
1533                 for _, v2 := range v {
1534                         ee.WriteArrayElem()
1535                         ee.EncodeString(cUTF8, v2)
1536                 }
1537         } else {
1538                 for _, v2 := range v {
1539                         ee.EncodeString(cUTF8, v2)
1540                 }
1541         }
1542         ee.WriteArrayEnd()
1543 }
1544 func (_ fastpathT) EncAsMapSliceStringV(v []string, e *Encoder) {
1545         ee, esep := e.e, e.hh.hasElemSeparators()
1546         if len(v)%2 == 1 {
1547                 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
1548                 return
1549         }
1550         ee.WriteMapStart(len(v) / 2)
1551         if esep {
1552                 for j, v2 := range v {
1553                         if j%2 == 0 {
1554                                 ee.WriteMapElemKey()
1555                         } else {
1556                                 ee.WriteMapElemValue()
1557                         }
1558                         ee.EncodeString(cUTF8, v2)
1559                 }
1560         } else {
1561                 for _, v2 := range v {
1562                         ee.EncodeString(cUTF8, v2)
1563                 }
1564         }
1565         ee.WriteMapEnd()
1566 }
1567
1568 func (e *Encoder) fastpathEncSliceFloat32R(f *codecFnInfo, rv reflect.Value) {
1569         if f.ti.mbs {
1570                 fastpathTV.EncAsMapSliceFloat32V(rv2i(rv).([]float32), e)
1571         } else {
1572                 fastpathTV.EncSliceFloat32V(rv2i(rv).([]float32), e)
1573         }
1574 }
1575 func (_ fastpathT) EncSliceFloat32V(v []float32, e *Encoder) {
1576         if v == nil {
1577                 e.e.EncodeNil()
1578                 return
1579         }
1580         ee, esep := e.e, e.hh.hasElemSeparators()
1581         ee.WriteArrayStart(len(v))
1582         if esep {
1583                 for _, v2 := range v {
1584                         ee.WriteArrayElem()
1585                         ee.EncodeFloat32(v2)
1586                 }
1587         } else {
1588                 for _, v2 := range v {
1589                         ee.EncodeFloat32(v2)
1590                 }
1591         }
1592         ee.WriteArrayEnd()
1593 }
1594 func (_ fastpathT) EncAsMapSliceFloat32V(v []float32, e *Encoder) {
1595         ee, esep := e.e, e.hh.hasElemSeparators()
1596         if len(v)%2 == 1 {
1597                 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
1598                 return
1599         }
1600         ee.WriteMapStart(len(v) / 2)
1601         if esep {
1602                 for j, v2 := range v {
1603                         if j%2 == 0 {
1604                                 ee.WriteMapElemKey()
1605                         } else {
1606                                 ee.WriteMapElemValue()
1607                         }
1608                         ee.EncodeFloat32(v2)
1609                 }
1610         } else {
1611                 for _, v2 := range v {
1612                         ee.EncodeFloat32(v2)
1613                 }
1614         }
1615         ee.WriteMapEnd()
1616 }
1617
1618 func (e *Encoder) fastpathEncSliceFloat64R(f *codecFnInfo, rv reflect.Value) {
1619         if f.ti.mbs {
1620                 fastpathTV.EncAsMapSliceFloat64V(rv2i(rv).([]float64), e)
1621         } else {
1622                 fastpathTV.EncSliceFloat64V(rv2i(rv).([]float64), e)
1623         }
1624 }
1625 func (_ fastpathT) EncSliceFloat64V(v []float64, e *Encoder) {
1626         if v == nil {
1627                 e.e.EncodeNil()
1628                 return
1629         }
1630         ee, esep := e.e, e.hh.hasElemSeparators()
1631         ee.WriteArrayStart(len(v))
1632         if esep {
1633                 for _, v2 := range v {
1634                         ee.WriteArrayElem()
1635                         ee.EncodeFloat64(v2)
1636                 }
1637         } else {
1638                 for _, v2 := range v {
1639                         ee.EncodeFloat64(v2)
1640                 }
1641         }
1642         ee.WriteArrayEnd()
1643 }
1644 func (_ fastpathT) EncAsMapSliceFloat64V(v []float64, e *Encoder) {
1645         ee, esep := e.e, e.hh.hasElemSeparators()
1646         if len(v)%2 == 1 {
1647                 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
1648                 return
1649         }
1650         ee.WriteMapStart(len(v) / 2)
1651         if esep {
1652                 for j, v2 := range v {
1653                         if j%2 == 0 {
1654                                 ee.WriteMapElemKey()
1655                         } else {
1656                                 ee.WriteMapElemValue()
1657                         }
1658                         ee.EncodeFloat64(v2)
1659                 }
1660         } else {
1661                 for _, v2 := range v {
1662                         ee.EncodeFloat64(v2)
1663                 }
1664         }
1665         ee.WriteMapEnd()
1666 }
1667
1668 func (e *Encoder) fastpathEncSliceUintR(f *codecFnInfo, rv reflect.Value) {
1669         if f.ti.mbs {
1670                 fastpathTV.EncAsMapSliceUintV(rv2i(rv).([]uint), e)
1671         } else {
1672                 fastpathTV.EncSliceUintV(rv2i(rv).([]uint), e)
1673         }
1674 }
1675 func (_ fastpathT) EncSliceUintV(v []uint, e *Encoder) {
1676         if v == nil {
1677                 e.e.EncodeNil()
1678                 return
1679         }
1680         ee, esep := e.e, e.hh.hasElemSeparators()
1681         ee.WriteArrayStart(len(v))
1682         if esep {
1683                 for _, v2 := range v {
1684                         ee.WriteArrayElem()
1685                         ee.EncodeUint(uint64(v2))
1686                 }
1687         } else {
1688                 for _, v2 := range v {
1689                         ee.EncodeUint(uint64(v2))
1690                 }
1691         }
1692         ee.WriteArrayEnd()
1693 }
1694 func (_ fastpathT) EncAsMapSliceUintV(v []uint, e *Encoder) {
1695         ee, esep := e.e, e.hh.hasElemSeparators()
1696         if len(v)%2 == 1 {
1697                 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
1698                 return
1699         }
1700         ee.WriteMapStart(len(v) / 2)
1701         if esep {
1702                 for j, v2 := range v {
1703                         if j%2 == 0 {
1704                                 ee.WriteMapElemKey()
1705                         } else {
1706                                 ee.WriteMapElemValue()
1707                         }
1708                         ee.EncodeUint(uint64(v2))
1709                 }
1710         } else {
1711                 for _, v2 := range v {
1712                         ee.EncodeUint(uint64(v2))
1713                 }
1714         }
1715         ee.WriteMapEnd()
1716 }
1717
1718 func (e *Encoder) fastpathEncSliceUint8R(f *codecFnInfo, rv reflect.Value) {
1719         if f.ti.mbs {
1720                 fastpathTV.EncAsMapSliceUint8V(rv2i(rv).([]uint8), e)
1721         } else {
1722                 fastpathTV.EncSliceUint8V(rv2i(rv).([]uint8), e)
1723         }
1724 }
1725 func (_ fastpathT) EncSliceUint8V(v []uint8, e *Encoder) {
1726         if v == nil {
1727                 e.e.EncodeNil()
1728                 return
1729         }
1730         ee, esep := e.e, e.hh.hasElemSeparators()
1731         ee.WriteArrayStart(len(v))
1732         if esep {
1733                 for _, v2 := range v {
1734                         ee.WriteArrayElem()
1735                         ee.EncodeUint(uint64(v2))
1736                 }
1737         } else {
1738                 for _, v2 := range v {
1739                         ee.EncodeUint(uint64(v2))
1740                 }
1741         }
1742         ee.WriteArrayEnd()
1743 }
1744 func (_ fastpathT) EncAsMapSliceUint8V(v []uint8, e *Encoder) {
1745         ee, esep := e.e, e.hh.hasElemSeparators()
1746         if len(v)%2 == 1 {
1747                 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
1748                 return
1749         }
1750         ee.WriteMapStart(len(v) / 2)
1751         if esep {
1752                 for j, v2 := range v {
1753                         if j%2 == 0 {
1754                                 ee.WriteMapElemKey()
1755                         } else {
1756                                 ee.WriteMapElemValue()
1757                         }
1758                         ee.EncodeUint(uint64(v2))
1759                 }
1760         } else {
1761                 for _, v2 := range v {
1762                         ee.EncodeUint(uint64(v2))
1763                 }
1764         }
1765         ee.WriteMapEnd()
1766 }
1767
1768 func (e *Encoder) fastpathEncSliceUint16R(f *codecFnInfo, rv reflect.Value) {
1769         if f.ti.mbs {
1770                 fastpathTV.EncAsMapSliceUint16V(rv2i(rv).([]uint16), e)
1771         } else {
1772                 fastpathTV.EncSliceUint16V(rv2i(rv).([]uint16), e)
1773         }
1774 }
1775 func (_ fastpathT) EncSliceUint16V(v []uint16, e *Encoder) {
1776         if v == nil {
1777                 e.e.EncodeNil()
1778                 return
1779         }
1780         ee, esep := e.e, e.hh.hasElemSeparators()
1781         ee.WriteArrayStart(len(v))
1782         if esep {
1783                 for _, v2 := range v {
1784                         ee.WriteArrayElem()
1785                         ee.EncodeUint(uint64(v2))
1786                 }
1787         } else {
1788                 for _, v2 := range v {
1789                         ee.EncodeUint(uint64(v2))
1790                 }
1791         }
1792         ee.WriteArrayEnd()
1793 }
1794 func (_ fastpathT) EncAsMapSliceUint16V(v []uint16, e *Encoder) {
1795         ee, esep := e.e, e.hh.hasElemSeparators()
1796         if len(v)%2 == 1 {
1797                 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
1798                 return
1799         }
1800         ee.WriteMapStart(len(v) / 2)
1801         if esep {
1802                 for j, v2 := range v {
1803                         if j%2 == 0 {
1804                                 ee.WriteMapElemKey()
1805                         } else {
1806                                 ee.WriteMapElemValue()
1807                         }
1808                         ee.EncodeUint(uint64(v2))
1809                 }
1810         } else {
1811                 for _, v2 := range v {
1812                         ee.EncodeUint(uint64(v2))
1813                 }
1814         }
1815         ee.WriteMapEnd()
1816 }
1817
1818 func (e *Encoder) fastpathEncSliceUint32R(f *codecFnInfo, rv reflect.Value) {
1819         if f.ti.mbs {
1820                 fastpathTV.EncAsMapSliceUint32V(rv2i(rv).([]uint32), e)
1821         } else {
1822                 fastpathTV.EncSliceUint32V(rv2i(rv).([]uint32), e)
1823         }
1824 }
1825 func (_ fastpathT) EncSliceUint32V(v []uint32, e *Encoder) {
1826         if v == nil {
1827                 e.e.EncodeNil()
1828                 return
1829         }
1830         ee, esep := e.e, e.hh.hasElemSeparators()
1831         ee.WriteArrayStart(len(v))
1832         if esep {
1833                 for _, v2 := range v {
1834                         ee.WriteArrayElem()
1835                         ee.EncodeUint(uint64(v2))
1836                 }
1837         } else {
1838                 for _, v2 := range v {
1839                         ee.EncodeUint(uint64(v2))
1840                 }
1841         }
1842         ee.WriteArrayEnd()
1843 }
1844 func (_ fastpathT) EncAsMapSliceUint32V(v []uint32, e *Encoder) {
1845         ee, esep := e.e, e.hh.hasElemSeparators()
1846         if len(v)%2 == 1 {
1847                 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
1848                 return
1849         }
1850         ee.WriteMapStart(len(v) / 2)
1851         if esep {
1852                 for j, v2 := range v {
1853                         if j%2 == 0 {
1854                                 ee.WriteMapElemKey()
1855                         } else {
1856                                 ee.WriteMapElemValue()
1857                         }
1858                         ee.EncodeUint(uint64(v2))
1859                 }
1860         } else {
1861                 for _, v2 := range v {
1862                         ee.EncodeUint(uint64(v2))
1863                 }
1864         }
1865         ee.WriteMapEnd()
1866 }
1867
1868 func (e *Encoder) fastpathEncSliceUint64R(f *codecFnInfo, rv reflect.Value) {
1869         if f.ti.mbs {
1870                 fastpathTV.EncAsMapSliceUint64V(rv2i(rv).([]uint64), e)
1871         } else {
1872                 fastpathTV.EncSliceUint64V(rv2i(rv).([]uint64), e)
1873         }
1874 }
1875 func (_ fastpathT) EncSliceUint64V(v []uint64, e *Encoder) {
1876         if v == nil {
1877                 e.e.EncodeNil()
1878                 return
1879         }
1880         ee, esep := e.e, e.hh.hasElemSeparators()
1881         ee.WriteArrayStart(len(v))
1882         if esep {
1883                 for _, v2 := range v {
1884                         ee.WriteArrayElem()
1885                         ee.EncodeUint(uint64(v2))
1886                 }
1887         } else {
1888                 for _, v2 := range v {
1889                         ee.EncodeUint(uint64(v2))
1890                 }
1891         }
1892         ee.WriteArrayEnd()
1893 }
1894 func (_ fastpathT) EncAsMapSliceUint64V(v []uint64, e *Encoder) {
1895         ee, esep := e.e, e.hh.hasElemSeparators()
1896         if len(v)%2 == 1 {
1897                 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
1898                 return
1899         }
1900         ee.WriteMapStart(len(v) / 2)
1901         if esep {
1902                 for j, v2 := range v {
1903                         if j%2 == 0 {
1904                                 ee.WriteMapElemKey()
1905                         } else {
1906                                 ee.WriteMapElemValue()
1907                         }
1908                         ee.EncodeUint(uint64(v2))
1909                 }
1910         } else {
1911                 for _, v2 := range v {
1912                         ee.EncodeUint(uint64(v2))
1913                 }
1914         }
1915         ee.WriteMapEnd()
1916 }
1917
1918 func (e *Encoder) fastpathEncSliceUintptrR(f *codecFnInfo, rv reflect.Value) {
1919         if f.ti.mbs {
1920                 fastpathTV.EncAsMapSliceUintptrV(rv2i(rv).([]uintptr), e)
1921         } else {
1922                 fastpathTV.EncSliceUintptrV(rv2i(rv).([]uintptr), e)
1923         }
1924 }
1925 func (_ fastpathT) EncSliceUintptrV(v []uintptr, e *Encoder) {
1926         if v == nil {
1927                 e.e.EncodeNil()
1928                 return
1929         }
1930         ee, esep := e.e, e.hh.hasElemSeparators()
1931         ee.WriteArrayStart(len(v))
1932         if esep {
1933                 for _, v2 := range v {
1934                         ee.WriteArrayElem()
1935                         e.encode(v2)
1936                 }
1937         } else {
1938                 for _, v2 := range v {
1939                         e.encode(v2)
1940                 }
1941         }
1942         ee.WriteArrayEnd()
1943 }
1944 func (_ fastpathT) EncAsMapSliceUintptrV(v []uintptr, e *Encoder) {
1945         ee, esep := e.e, e.hh.hasElemSeparators()
1946         if len(v)%2 == 1 {
1947                 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
1948                 return
1949         }
1950         ee.WriteMapStart(len(v) / 2)
1951         if esep {
1952                 for j, v2 := range v {
1953                         if j%2 == 0 {
1954                                 ee.WriteMapElemKey()
1955                         } else {
1956                                 ee.WriteMapElemValue()
1957                         }
1958                         e.encode(v2)
1959                 }
1960         } else {
1961                 for _, v2 := range v {
1962                         e.encode(v2)
1963                 }
1964         }
1965         ee.WriteMapEnd()
1966 }
1967
1968 func (e *Encoder) fastpathEncSliceIntR(f *codecFnInfo, rv reflect.Value) {
1969         if f.ti.mbs {
1970                 fastpathTV.EncAsMapSliceIntV(rv2i(rv).([]int), e)
1971         } else {
1972                 fastpathTV.EncSliceIntV(rv2i(rv).([]int), e)
1973         }
1974 }
1975 func (_ fastpathT) EncSliceIntV(v []int, e *Encoder) {
1976         if v == nil {
1977                 e.e.EncodeNil()
1978                 return
1979         }
1980         ee, esep := e.e, e.hh.hasElemSeparators()
1981         ee.WriteArrayStart(len(v))
1982         if esep {
1983                 for _, v2 := range v {
1984                         ee.WriteArrayElem()
1985                         ee.EncodeInt(int64(v2))
1986                 }
1987         } else {
1988                 for _, v2 := range v {
1989                         ee.EncodeInt(int64(v2))
1990                 }
1991         }
1992         ee.WriteArrayEnd()
1993 }
1994 func (_ fastpathT) EncAsMapSliceIntV(v []int, e *Encoder) {
1995         ee, esep := e.e, e.hh.hasElemSeparators()
1996         if len(v)%2 == 1 {
1997                 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
1998                 return
1999         }
2000         ee.WriteMapStart(len(v) / 2)
2001         if esep {
2002                 for j, v2 := range v {
2003                         if j%2 == 0 {
2004                                 ee.WriteMapElemKey()
2005                         } else {
2006                                 ee.WriteMapElemValue()
2007                         }
2008                         ee.EncodeInt(int64(v2))
2009                 }
2010         } else {
2011                 for _, v2 := range v {
2012                         ee.EncodeInt(int64(v2))
2013                 }
2014         }
2015         ee.WriteMapEnd()
2016 }
2017
2018 func (e *Encoder) fastpathEncSliceInt8R(f *codecFnInfo, rv reflect.Value) {
2019         if f.ti.mbs {
2020                 fastpathTV.EncAsMapSliceInt8V(rv2i(rv).([]int8), e)
2021         } else {
2022                 fastpathTV.EncSliceInt8V(rv2i(rv).([]int8), e)
2023         }
2024 }
2025 func (_ fastpathT) EncSliceInt8V(v []int8, e *Encoder) {
2026         if v == nil {
2027                 e.e.EncodeNil()
2028                 return
2029         }
2030         ee, esep := e.e, e.hh.hasElemSeparators()
2031         ee.WriteArrayStart(len(v))
2032         if esep {
2033                 for _, v2 := range v {
2034                         ee.WriteArrayElem()
2035                         ee.EncodeInt(int64(v2))
2036                 }
2037         } else {
2038                 for _, v2 := range v {
2039                         ee.EncodeInt(int64(v2))
2040                 }
2041         }
2042         ee.WriteArrayEnd()
2043 }
2044 func (_ fastpathT) EncAsMapSliceInt8V(v []int8, e *Encoder) {
2045         ee, esep := e.e, e.hh.hasElemSeparators()
2046         if len(v)%2 == 1 {
2047                 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
2048                 return
2049         }
2050         ee.WriteMapStart(len(v) / 2)
2051         if esep {
2052                 for j, v2 := range v {
2053                         if j%2 == 0 {
2054                                 ee.WriteMapElemKey()
2055                         } else {
2056                                 ee.WriteMapElemValue()
2057                         }
2058                         ee.EncodeInt(int64(v2))
2059                 }
2060         } else {
2061                 for _, v2 := range v {
2062                         ee.EncodeInt(int64(v2))
2063                 }
2064         }
2065         ee.WriteMapEnd()
2066 }
2067
2068 func (e *Encoder) fastpathEncSliceInt16R(f *codecFnInfo, rv reflect.Value) {
2069         if f.ti.mbs {
2070                 fastpathTV.EncAsMapSliceInt16V(rv2i(rv).([]int16), e)
2071         } else {
2072                 fastpathTV.EncSliceInt16V(rv2i(rv).([]int16), e)
2073         }
2074 }
2075 func (_ fastpathT) EncSliceInt16V(v []int16, e *Encoder) {
2076         if v == nil {
2077                 e.e.EncodeNil()
2078                 return
2079         }
2080         ee, esep := e.e, e.hh.hasElemSeparators()
2081         ee.WriteArrayStart(len(v))
2082         if esep {
2083                 for _, v2 := range v {
2084                         ee.WriteArrayElem()
2085                         ee.EncodeInt(int64(v2))
2086                 }
2087         } else {
2088                 for _, v2 := range v {
2089                         ee.EncodeInt(int64(v2))
2090                 }
2091         }
2092         ee.WriteArrayEnd()
2093 }
2094 func (_ fastpathT) EncAsMapSliceInt16V(v []int16, e *Encoder) {
2095         ee, esep := e.e, e.hh.hasElemSeparators()
2096         if len(v)%2 == 1 {
2097                 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
2098                 return
2099         }
2100         ee.WriteMapStart(len(v) / 2)
2101         if esep {
2102                 for j, v2 := range v {
2103                         if j%2 == 0 {
2104                                 ee.WriteMapElemKey()
2105                         } else {
2106                                 ee.WriteMapElemValue()
2107                         }
2108                         ee.EncodeInt(int64(v2))
2109                 }
2110         } else {
2111                 for _, v2 := range v {
2112                         ee.EncodeInt(int64(v2))
2113                 }
2114         }
2115         ee.WriteMapEnd()
2116 }
2117
2118 func (e *Encoder) fastpathEncSliceInt32R(f *codecFnInfo, rv reflect.Value) {
2119         if f.ti.mbs {
2120                 fastpathTV.EncAsMapSliceInt32V(rv2i(rv).([]int32), e)
2121         } else {
2122                 fastpathTV.EncSliceInt32V(rv2i(rv).([]int32), e)
2123         }
2124 }
2125 func (_ fastpathT) EncSliceInt32V(v []int32, e *Encoder) {
2126         if v == nil {
2127                 e.e.EncodeNil()
2128                 return
2129         }
2130         ee, esep := e.e, e.hh.hasElemSeparators()
2131         ee.WriteArrayStart(len(v))
2132         if esep {
2133                 for _, v2 := range v {
2134                         ee.WriteArrayElem()
2135                         ee.EncodeInt(int64(v2))
2136                 }
2137         } else {
2138                 for _, v2 := range v {
2139                         ee.EncodeInt(int64(v2))
2140                 }
2141         }
2142         ee.WriteArrayEnd()
2143 }
2144 func (_ fastpathT) EncAsMapSliceInt32V(v []int32, e *Encoder) {
2145         ee, esep := e.e, e.hh.hasElemSeparators()
2146         if len(v)%2 == 1 {
2147                 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
2148                 return
2149         }
2150         ee.WriteMapStart(len(v) / 2)
2151         if esep {
2152                 for j, v2 := range v {
2153                         if j%2 == 0 {
2154                                 ee.WriteMapElemKey()
2155                         } else {
2156                                 ee.WriteMapElemValue()
2157                         }
2158                         ee.EncodeInt(int64(v2))
2159                 }
2160         } else {
2161                 for _, v2 := range v {
2162                         ee.EncodeInt(int64(v2))
2163                 }
2164         }
2165         ee.WriteMapEnd()
2166 }
2167
2168 func (e *Encoder) fastpathEncSliceInt64R(f *codecFnInfo, rv reflect.Value) {
2169         if f.ti.mbs {
2170                 fastpathTV.EncAsMapSliceInt64V(rv2i(rv).([]int64), e)
2171         } else {
2172                 fastpathTV.EncSliceInt64V(rv2i(rv).([]int64), e)
2173         }
2174 }
2175 func (_ fastpathT) EncSliceInt64V(v []int64, e *Encoder) {
2176         if v == nil {
2177                 e.e.EncodeNil()
2178                 return
2179         }
2180         ee, esep := e.e, e.hh.hasElemSeparators()
2181         ee.WriteArrayStart(len(v))
2182         if esep {
2183                 for _, v2 := range v {
2184                         ee.WriteArrayElem()
2185                         ee.EncodeInt(int64(v2))
2186                 }
2187         } else {
2188                 for _, v2 := range v {
2189                         ee.EncodeInt(int64(v2))
2190                 }
2191         }
2192         ee.WriteArrayEnd()
2193 }
2194 func (_ fastpathT) EncAsMapSliceInt64V(v []int64, e *Encoder) {
2195         ee, esep := e.e, e.hh.hasElemSeparators()
2196         if len(v)%2 == 1 {
2197                 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
2198                 return
2199         }
2200         ee.WriteMapStart(len(v) / 2)
2201         if esep {
2202                 for j, v2 := range v {
2203                         if j%2 == 0 {
2204                                 ee.WriteMapElemKey()
2205                         } else {
2206                                 ee.WriteMapElemValue()
2207                         }
2208                         ee.EncodeInt(int64(v2))
2209                 }
2210         } else {
2211                 for _, v2 := range v {
2212                         ee.EncodeInt(int64(v2))
2213                 }
2214         }
2215         ee.WriteMapEnd()
2216 }
2217
2218 func (e *Encoder) fastpathEncSliceBoolR(f *codecFnInfo, rv reflect.Value) {
2219         if f.ti.mbs {
2220                 fastpathTV.EncAsMapSliceBoolV(rv2i(rv).([]bool), e)
2221         } else {
2222                 fastpathTV.EncSliceBoolV(rv2i(rv).([]bool), e)
2223         }
2224 }
2225 func (_ fastpathT) EncSliceBoolV(v []bool, e *Encoder) {
2226         if v == nil {
2227                 e.e.EncodeNil()
2228                 return
2229         }
2230         ee, esep := e.e, e.hh.hasElemSeparators()
2231         ee.WriteArrayStart(len(v))
2232         if esep {
2233                 for _, v2 := range v {
2234                         ee.WriteArrayElem()
2235                         ee.EncodeBool(v2)
2236                 }
2237         } else {
2238                 for _, v2 := range v {
2239                         ee.EncodeBool(v2)
2240                 }
2241         }
2242         ee.WriteArrayEnd()
2243 }
2244 func (_ fastpathT) EncAsMapSliceBoolV(v []bool, e *Encoder) {
2245         ee, esep := e.e, e.hh.hasElemSeparators()
2246         if len(v)%2 == 1 {
2247                 e.errorf("mapBySlice requires even slice length, but got %v", len(v))
2248                 return
2249         }
2250         ee.WriteMapStart(len(v) / 2)
2251         if esep {
2252                 for j, v2 := range v {
2253                         if j%2 == 0 {
2254                                 ee.WriteMapElemKey()
2255                         } else {
2256                                 ee.WriteMapElemValue()
2257                         }
2258                         ee.EncodeBool(v2)
2259                 }
2260         } else {
2261                 for _, v2 := range v {
2262                         ee.EncodeBool(v2)
2263                 }
2264         }
2265         ee.WriteMapEnd()
2266 }
2267
2268 func (e *Encoder) fastpathEncMapIntfIntfR(f *codecFnInfo, rv reflect.Value) {
2269         fastpathTV.EncMapIntfIntfV(rv2i(rv).(map[interface{}]interface{}), e)
2270 }
2271 func (_ fastpathT) EncMapIntfIntfV(v map[interface{}]interface{}, e *Encoder) {
2272         if v == nil {
2273                 e.e.EncodeNil()
2274                 return
2275         }
2276         ee, esep := e.e, e.hh.hasElemSeparators()
2277         ee.WriteMapStart(len(v))
2278         if e.h.Canonical {
2279                 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2280                 e2 := NewEncoderBytes(&mksv, e.hh)
2281                 v2 := make([]bytesI, len(v))
2282                 var i, l int
2283                 var vp *bytesI
2284                 for k2, _ := range v {
2285                         l = len(mksv)
2286                         e2.MustEncode(k2)
2287                         vp = &v2[i]
2288                         vp.v = mksv[l:]
2289                         vp.i = k2
2290                         i++
2291                 }
2292                 sort.Sort(bytesISlice(v2))
2293                 if esep {
2294                         for j := range v2 {
2295                                 ee.WriteMapElemKey()
2296                                 e.asis(v2[j].v)
2297                                 ee.WriteMapElemValue()
2298                                 e.encode(v[v2[j].i])
2299                         }
2300                 } else {
2301                         for j := range v2 {
2302                                 e.asis(v2[j].v)
2303                                 e.encode(v[v2[j].i])
2304                         }
2305                 }
2306         } else {
2307                 if esep {
2308                         for k2, v2 := range v {
2309                                 ee.WriteMapElemKey()
2310                                 e.encode(k2)
2311                                 ee.WriteMapElemValue()
2312                                 e.encode(v2)
2313                         }
2314                 } else {
2315                         for k2, v2 := range v {
2316                                 e.encode(k2)
2317                                 e.encode(v2)
2318                         }
2319                 }
2320         }
2321         ee.WriteMapEnd()
2322 }
2323
2324 func (e *Encoder) fastpathEncMapIntfStringR(f *codecFnInfo, rv reflect.Value) {
2325         fastpathTV.EncMapIntfStringV(rv2i(rv).(map[interface{}]string), e)
2326 }
2327 func (_ fastpathT) EncMapIntfStringV(v map[interface{}]string, e *Encoder) {
2328         if v == nil {
2329                 e.e.EncodeNil()
2330                 return
2331         }
2332         ee, esep := e.e, e.hh.hasElemSeparators()
2333         ee.WriteMapStart(len(v))
2334         if e.h.Canonical {
2335                 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2336                 e2 := NewEncoderBytes(&mksv, e.hh)
2337                 v2 := make([]bytesI, len(v))
2338                 var i, l int
2339                 var vp *bytesI
2340                 for k2, _ := range v {
2341                         l = len(mksv)
2342                         e2.MustEncode(k2)
2343                         vp = &v2[i]
2344                         vp.v = mksv[l:]
2345                         vp.i = k2
2346                         i++
2347                 }
2348                 sort.Sort(bytesISlice(v2))
2349                 if esep {
2350                         for j := range v2 {
2351                                 ee.WriteMapElemKey()
2352                                 e.asis(v2[j].v)
2353                                 ee.WriteMapElemValue()
2354                                 e.encode(v[v2[j].i])
2355                         }
2356                 } else {
2357                         for j := range v2 {
2358                                 e.asis(v2[j].v)
2359                                 e.encode(v[v2[j].i])
2360                         }
2361                 }
2362         } else {
2363                 if esep {
2364                         for k2, v2 := range v {
2365                                 ee.WriteMapElemKey()
2366                                 e.encode(k2)
2367                                 ee.WriteMapElemValue()
2368                                 ee.EncodeString(cUTF8, v2)
2369                         }
2370                 } else {
2371                         for k2, v2 := range v {
2372                                 e.encode(k2)
2373                                 ee.EncodeString(cUTF8, v2)
2374                         }
2375                 }
2376         }
2377         ee.WriteMapEnd()
2378 }
2379
2380 func (e *Encoder) fastpathEncMapIntfUintR(f *codecFnInfo, rv reflect.Value) {
2381         fastpathTV.EncMapIntfUintV(rv2i(rv).(map[interface{}]uint), e)
2382 }
2383 func (_ fastpathT) EncMapIntfUintV(v map[interface{}]uint, e *Encoder) {
2384         if v == nil {
2385                 e.e.EncodeNil()
2386                 return
2387         }
2388         ee, esep := e.e, e.hh.hasElemSeparators()
2389         ee.WriteMapStart(len(v))
2390         if e.h.Canonical {
2391                 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2392                 e2 := NewEncoderBytes(&mksv, e.hh)
2393                 v2 := make([]bytesI, len(v))
2394                 var i, l int
2395                 var vp *bytesI
2396                 for k2, _ := range v {
2397                         l = len(mksv)
2398                         e2.MustEncode(k2)
2399                         vp = &v2[i]
2400                         vp.v = mksv[l:]
2401                         vp.i = k2
2402                         i++
2403                 }
2404                 sort.Sort(bytesISlice(v2))
2405                 if esep {
2406                         for j := range v2 {
2407                                 ee.WriteMapElemKey()
2408                                 e.asis(v2[j].v)
2409                                 ee.WriteMapElemValue()
2410                                 e.encode(v[v2[j].i])
2411                         }
2412                 } else {
2413                         for j := range v2 {
2414                                 e.asis(v2[j].v)
2415                                 e.encode(v[v2[j].i])
2416                         }
2417                 }
2418         } else {
2419                 if esep {
2420                         for k2, v2 := range v {
2421                                 ee.WriteMapElemKey()
2422                                 e.encode(k2)
2423                                 ee.WriteMapElemValue()
2424                                 ee.EncodeUint(uint64(v2))
2425                         }
2426                 } else {
2427                         for k2, v2 := range v {
2428                                 e.encode(k2)
2429                                 ee.EncodeUint(uint64(v2))
2430                         }
2431                 }
2432         }
2433         ee.WriteMapEnd()
2434 }
2435
2436 func (e *Encoder) fastpathEncMapIntfUint8R(f *codecFnInfo, rv reflect.Value) {
2437         fastpathTV.EncMapIntfUint8V(rv2i(rv).(map[interface{}]uint8), e)
2438 }
2439 func (_ fastpathT) EncMapIntfUint8V(v map[interface{}]uint8, e *Encoder) {
2440         if v == nil {
2441                 e.e.EncodeNil()
2442                 return
2443         }
2444         ee, esep := e.e, e.hh.hasElemSeparators()
2445         ee.WriteMapStart(len(v))
2446         if e.h.Canonical {
2447                 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2448                 e2 := NewEncoderBytes(&mksv, e.hh)
2449                 v2 := make([]bytesI, len(v))
2450                 var i, l int
2451                 var vp *bytesI
2452                 for k2, _ := range v {
2453                         l = len(mksv)
2454                         e2.MustEncode(k2)
2455                         vp = &v2[i]
2456                         vp.v = mksv[l:]
2457                         vp.i = k2
2458                         i++
2459                 }
2460                 sort.Sort(bytesISlice(v2))
2461                 if esep {
2462                         for j := range v2 {
2463                                 ee.WriteMapElemKey()
2464                                 e.asis(v2[j].v)
2465                                 ee.WriteMapElemValue()
2466                                 e.encode(v[v2[j].i])
2467                         }
2468                 } else {
2469                         for j := range v2 {
2470                                 e.asis(v2[j].v)
2471                                 e.encode(v[v2[j].i])
2472                         }
2473                 }
2474         } else {
2475                 if esep {
2476                         for k2, v2 := range v {
2477                                 ee.WriteMapElemKey()
2478                                 e.encode(k2)
2479                                 ee.WriteMapElemValue()
2480                                 ee.EncodeUint(uint64(v2))
2481                         }
2482                 } else {
2483                         for k2, v2 := range v {
2484                                 e.encode(k2)
2485                                 ee.EncodeUint(uint64(v2))
2486                         }
2487                 }
2488         }
2489         ee.WriteMapEnd()
2490 }
2491
2492 func (e *Encoder) fastpathEncMapIntfUint16R(f *codecFnInfo, rv reflect.Value) {
2493         fastpathTV.EncMapIntfUint16V(rv2i(rv).(map[interface{}]uint16), e)
2494 }
2495 func (_ fastpathT) EncMapIntfUint16V(v map[interface{}]uint16, e *Encoder) {
2496         if v == nil {
2497                 e.e.EncodeNil()
2498                 return
2499         }
2500         ee, esep := e.e, e.hh.hasElemSeparators()
2501         ee.WriteMapStart(len(v))
2502         if e.h.Canonical {
2503                 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2504                 e2 := NewEncoderBytes(&mksv, e.hh)
2505                 v2 := make([]bytesI, len(v))
2506                 var i, l int
2507                 var vp *bytesI
2508                 for k2, _ := range v {
2509                         l = len(mksv)
2510                         e2.MustEncode(k2)
2511                         vp = &v2[i]
2512                         vp.v = mksv[l:]
2513                         vp.i = k2
2514                         i++
2515                 }
2516                 sort.Sort(bytesISlice(v2))
2517                 if esep {
2518                         for j := range v2 {
2519                                 ee.WriteMapElemKey()
2520                                 e.asis(v2[j].v)
2521                                 ee.WriteMapElemValue()
2522                                 e.encode(v[v2[j].i])
2523                         }
2524                 } else {
2525                         for j := range v2 {
2526                                 e.asis(v2[j].v)
2527                                 e.encode(v[v2[j].i])
2528                         }
2529                 }
2530         } else {
2531                 if esep {
2532                         for k2, v2 := range v {
2533                                 ee.WriteMapElemKey()
2534                                 e.encode(k2)
2535                                 ee.WriteMapElemValue()
2536                                 ee.EncodeUint(uint64(v2))
2537                         }
2538                 } else {
2539                         for k2, v2 := range v {
2540                                 e.encode(k2)
2541                                 ee.EncodeUint(uint64(v2))
2542                         }
2543                 }
2544         }
2545         ee.WriteMapEnd()
2546 }
2547
2548 func (e *Encoder) fastpathEncMapIntfUint32R(f *codecFnInfo, rv reflect.Value) {
2549         fastpathTV.EncMapIntfUint32V(rv2i(rv).(map[interface{}]uint32), e)
2550 }
2551 func (_ fastpathT) EncMapIntfUint32V(v map[interface{}]uint32, e *Encoder) {
2552         if v == nil {
2553                 e.e.EncodeNil()
2554                 return
2555         }
2556         ee, esep := e.e, e.hh.hasElemSeparators()
2557         ee.WriteMapStart(len(v))
2558         if e.h.Canonical {
2559                 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2560                 e2 := NewEncoderBytes(&mksv, e.hh)
2561                 v2 := make([]bytesI, len(v))
2562                 var i, l int
2563                 var vp *bytesI
2564                 for k2, _ := range v {
2565                         l = len(mksv)
2566                         e2.MustEncode(k2)
2567                         vp = &v2[i]
2568                         vp.v = mksv[l:]
2569                         vp.i = k2
2570                         i++
2571                 }
2572                 sort.Sort(bytesISlice(v2))
2573                 if esep {
2574                         for j := range v2 {
2575                                 ee.WriteMapElemKey()
2576                                 e.asis(v2[j].v)
2577                                 ee.WriteMapElemValue()
2578                                 e.encode(v[v2[j].i])
2579                         }
2580                 } else {
2581                         for j := range v2 {
2582                                 e.asis(v2[j].v)
2583                                 e.encode(v[v2[j].i])
2584                         }
2585                 }
2586         } else {
2587                 if esep {
2588                         for k2, v2 := range v {
2589                                 ee.WriteMapElemKey()
2590                                 e.encode(k2)
2591                                 ee.WriteMapElemValue()
2592                                 ee.EncodeUint(uint64(v2))
2593                         }
2594                 } else {
2595                         for k2, v2 := range v {
2596                                 e.encode(k2)
2597                                 ee.EncodeUint(uint64(v2))
2598                         }
2599                 }
2600         }
2601         ee.WriteMapEnd()
2602 }
2603
2604 func (e *Encoder) fastpathEncMapIntfUint64R(f *codecFnInfo, rv reflect.Value) {
2605         fastpathTV.EncMapIntfUint64V(rv2i(rv).(map[interface{}]uint64), e)
2606 }
2607 func (_ fastpathT) EncMapIntfUint64V(v map[interface{}]uint64, e *Encoder) {
2608         if v == nil {
2609                 e.e.EncodeNil()
2610                 return
2611         }
2612         ee, esep := e.e, e.hh.hasElemSeparators()
2613         ee.WriteMapStart(len(v))
2614         if e.h.Canonical {
2615                 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2616                 e2 := NewEncoderBytes(&mksv, e.hh)
2617                 v2 := make([]bytesI, len(v))
2618                 var i, l int
2619                 var vp *bytesI
2620                 for k2, _ := range v {
2621                         l = len(mksv)
2622                         e2.MustEncode(k2)
2623                         vp = &v2[i]
2624                         vp.v = mksv[l:]
2625                         vp.i = k2
2626                         i++
2627                 }
2628                 sort.Sort(bytesISlice(v2))
2629                 if esep {
2630                         for j := range v2 {
2631                                 ee.WriteMapElemKey()
2632                                 e.asis(v2[j].v)
2633                                 ee.WriteMapElemValue()
2634                                 e.encode(v[v2[j].i])
2635                         }
2636                 } else {
2637                         for j := range v2 {
2638                                 e.asis(v2[j].v)
2639                                 e.encode(v[v2[j].i])
2640                         }
2641                 }
2642         } else {
2643                 if esep {
2644                         for k2, v2 := range v {
2645                                 ee.WriteMapElemKey()
2646                                 e.encode(k2)
2647                                 ee.WriteMapElemValue()
2648                                 ee.EncodeUint(uint64(v2))
2649                         }
2650                 } else {
2651                         for k2, v2 := range v {
2652                                 e.encode(k2)
2653                                 ee.EncodeUint(uint64(v2))
2654                         }
2655                 }
2656         }
2657         ee.WriteMapEnd()
2658 }
2659
2660 func (e *Encoder) fastpathEncMapIntfUintptrR(f *codecFnInfo, rv reflect.Value) {
2661         fastpathTV.EncMapIntfUintptrV(rv2i(rv).(map[interface{}]uintptr), e)
2662 }
2663 func (_ fastpathT) EncMapIntfUintptrV(v map[interface{}]uintptr, e *Encoder) {
2664         if v == nil {
2665                 e.e.EncodeNil()
2666                 return
2667         }
2668         ee, esep := e.e, e.hh.hasElemSeparators()
2669         ee.WriteMapStart(len(v))
2670         if e.h.Canonical {
2671                 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2672                 e2 := NewEncoderBytes(&mksv, e.hh)
2673                 v2 := make([]bytesI, len(v))
2674                 var i, l int
2675                 var vp *bytesI
2676                 for k2, _ := range v {
2677                         l = len(mksv)
2678                         e2.MustEncode(k2)
2679                         vp = &v2[i]
2680                         vp.v = mksv[l:]
2681                         vp.i = k2
2682                         i++
2683                 }
2684                 sort.Sort(bytesISlice(v2))
2685                 if esep {
2686                         for j := range v2 {
2687                                 ee.WriteMapElemKey()
2688                                 e.asis(v2[j].v)
2689                                 ee.WriteMapElemValue()
2690                                 e.encode(v[v2[j].i])
2691                         }
2692                 } else {
2693                         for j := range v2 {
2694                                 e.asis(v2[j].v)
2695                                 e.encode(v[v2[j].i])
2696                         }
2697                 }
2698         } else {
2699                 if esep {
2700                         for k2, v2 := range v {
2701                                 ee.WriteMapElemKey()
2702                                 e.encode(k2)
2703                                 ee.WriteMapElemValue()
2704                                 e.encode(v2)
2705                         }
2706                 } else {
2707                         for k2, v2 := range v {
2708                                 e.encode(k2)
2709                                 e.encode(v2)
2710                         }
2711                 }
2712         }
2713         ee.WriteMapEnd()
2714 }
2715
2716 func (e *Encoder) fastpathEncMapIntfIntR(f *codecFnInfo, rv reflect.Value) {
2717         fastpathTV.EncMapIntfIntV(rv2i(rv).(map[interface{}]int), e)
2718 }
2719 func (_ fastpathT) EncMapIntfIntV(v map[interface{}]int, e *Encoder) {
2720         if v == nil {
2721                 e.e.EncodeNil()
2722                 return
2723         }
2724         ee, esep := e.e, e.hh.hasElemSeparators()
2725         ee.WriteMapStart(len(v))
2726         if e.h.Canonical {
2727                 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2728                 e2 := NewEncoderBytes(&mksv, e.hh)
2729                 v2 := make([]bytesI, len(v))
2730                 var i, l int
2731                 var vp *bytesI
2732                 for k2, _ := range v {
2733                         l = len(mksv)
2734                         e2.MustEncode(k2)
2735                         vp = &v2[i]
2736                         vp.v = mksv[l:]
2737                         vp.i = k2
2738                         i++
2739                 }
2740                 sort.Sort(bytesISlice(v2))
2741                 if esep {
2742                         for j := range v2 {
2743                                 ee.WriteMapElemKey()
2744                                 e.asis(v2[j].v)
2745                                 ee.WriteMapElemValue()
2746                                 e.encode(v[v2[j].i])
2747                         }
2748                 } else {
2749                         for j := range v2 {
2750                                 e.asis(v2[j].v)
2751                                 e.encode(v[v2[j].i])
2752                         }
2753                 }
2754         } else {
2755                 if esep {
2756                         for k2, v2 := range v {
2757                                 ee.WriteMapElemKey()
2758                                 e.encode(k2)
2759                                 ee.WriteMapElemValue()
2760                                 ee.EncodeInt(int64(v2))
2761                         }
2762                 } else {
2763                         for k2, v2 := range v {
2764                                 e.encode(k2)
2765                                 ee.EncodeInt(int64(v2))
2766                         }
2767                 }
2768         }
2769         ee.WriteMapEnd()
2770 }
2771
2772 func (e *Encoder) fastpathEncMapIntfInt8R(f *codecFnInfo, rv reflect.Value) {
2773         fastpathTV.EncMapIntfInt8V(rv2i(rv).(map[interface{}]int8), e)
2774 }
2775 func (_ fastpathT) EncMapIntfInt8V(v map[interface{}]int8, e *Encoder) {
2776         if v == nil {
2777                 e.e.EncodeNil()
2778                 return
2779         }
2780         ee, esep := e.e, e.hh.hasElemSeparators()
2781         ee.WriteMapStart(len(v))
2782         if e.h.Canonical {
2783                 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2784                 e2 := NewEncoderBytes(&mksv, e.hh)
2785                 v2 := make([]bytesI, len(v))
2786                 var i, l int
2787                 var vp *bytesI
2788                 for k2, _ := range v {
2789                         l = len(mksv)
2790                         e2.MustEncode(k2)
2791                         vp = &v2[i]
2792                         vp.v = mksv[l:]
2793                         vp.i = k2
2794                         i++
2795                 }
2796                 sort.Sort(bytesISlice(v2))
2797                 if esep {
2798                         for j := range v2 {
2799                                 ee.WriteMapElemKey()
2800                                 e.asis(v2[j].v)
2801                                 ee.WriteMapElemValue()
2802                                 e.encode(v[v2[j].i])
2803                         }
2804                 } else {
2805                         for j := range v2 {
2806                                 e.asis(v2[j].v)
2807                                 e.encode(v[v2[j].i])
2808                         }
2809                 }
2810         } else {
2811                 if esep {
2812                         for k2, v2 := range v {
2813                                 ee.WriteMapElemKey()
2814                                 e.encode(k2)
2815                                 ee.WriteMapElemValue()
2816                                 ee.EncodeInt(int64(v2))
2817                         }
2818                 } else {
2819                         for k2, v2 := range v {
2820                                 e.encode(k2)
2821                                 ee.EncodeInt(int64(v2))
2822                         }
2823                 }
2824         }
2825         ee.WriteMapEnd()
2826 }
2827
2828 func (e *Encoder) fastpathEncMapIntfInt16R(f *codecFnInfo, rv reflect.Value) {
2829         fastpathTV.EncMapIntfInt16V(rv2i(rv).(map[interface{}]int16), e)
2830 }
2831 func (_ fastpathT) EncMapIntfInt16V(v map[interface{}]int16, e *Encoder) {
2832         if v == nil {
2833                 e.e.EncodeNil()
2834                 return
2835         }
2836         ee, esep := e.e, e.hh.hasElemSeparators()
2837         ee.WriteMapStart(len(v))
2838         if e.h.Canonical {
2839                 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2840                 e2 := NewEncoderBytes(&mksv, e.hh)
2841                 v2 := make([]bytesI, len(v))
2842                 var i, l int
2843                 var vp *bytesI
2844                 for k2, _ := range v {
2845                         l = len(mksv)
2846                         e2.MustEncode(k2)
2847                         vp = &v2[i]
2848                         vp.v = mksv[l:]
2849                         vp.i = k2
2850                         i++
2851                 }
2852                 sort.Sort(bytesISlice(v2))
2853                 if esep {
2854                         for j := range v2 {
2855                                 ee.WriteMapElemKey()
2856                                 e.asis(v2[j].v)
2857                                 ee.WriteMapElemValue()
2858                                 e.encode(v[v2[j].i])
2859                         }
2860                 } else {
2861                         for j := range v2 {
2862                                 e.asis(v2[j].v)
2863                                 e.encode(v[v2[j].i])
2864                         }
2865                 }
2866         } else {
2867                 if esep {
2868                         for k2, v2 := range v {
2869                                 ee.WriteMapElemKey()
2870                                 e.encode(k2)
2871                                 ee.WriteMapElemValue()
2872                                 ee.EncodeInt(int64(v2))
2873                         }
2874                 } else {
2875                         for k2, v2 := range v {
2876                                 e.encode(k2)
2877                                 ee.EncodeInt(int64(v2))
2878                         }
2879                 }
2880         }
2881         ee.WriteMapEnd()
2882 }
2883
2884 func (e *Encoder) fastpathEncMapIntfInt32R(f *codecFnInfo, rv reflect.Value) {
2885         fastpathTV.EncMapIntfInt32V(rv2i(rv).(map[interface{}]int32), e)
2886 }
2887 func (_ fastpathT) EncMapIntfInt32V(v map[interface{}]int32, e *Encoder) {
2888         if v == nil {
2889                 e.e.EncodeNil()
2890                 return
2891         }
2892         ee, esep := e.e, e.hh.hasElemSeparators()
2893         ee.WriteMapStart(len(v))
2894         if e.h.Canonical {
2895                 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2896                 e2 := NewEncoderBytes(&mksv, e.hh)
2897                 v2 := make([]bytesI, len(v))
2898                 var i, l int
2899                 var vp *bytesI
2900                 for k2, _ := range v {
2901                         l = len(mksv)
2902                         e2.MustEncode(k2)
2903                         vp = &v2[i]
2904                         vp.v = mksv[l:]
2905                         vp.i = k2
2906                         i++
2907                 }
2908                 sort.Sort(bytesISlice(v2))
2909                 if esep {
2910                         for j := range v2 {
2911                                 ee.WriteMapElemKey()
2912                                 e.asis(v2[j].v)
2913                                 ee.WriteMapElemValue()
2914                                 e.encode(v[v2[j].i])
2915                         }
2916                 } else {
2917                         for j := range v2 {
2918                                 e.asis(v2[j].v)
2919                                 e.encode(v[v2[j].i])
2920                         }
2921                 }
2922         } else {
2923                 if esep {
2924                         for k2, v2 := range v {
2925                                 ee.WriteMapElemKey()
2926                                 e.encode(k2)
2927                                 ee.WriteMapElemValue()
2928                                 ee.EncodeInt(int64(v2))
2929                         }
2930                 } else {
2931                         for k2, v2 := range v {
2932                                 e.encode(k2)
2933                                 ee.EncodeInt(int64(v2))
2934                         }
2935                 }
2936         }
2937         ee.WriteMapEnd()
2938 }
2939
2940 func (e *Encoder) fastpathEncMapIntfInt64R(f *codecFnInfo, rv reflect.Value) {
2941         fastpathTV.EncMapIntfInt64V(rv2i(rv).(map[interface{}]int64), e)
2942 }
2943 func (_ fastpathT) EncMapIntfInt64V(v map[interface{}]int64, e *Encoder) {
2944         if v == nil {
2945                 e.e.EncodeNil()
2946                 return
2947         }
2948         ee, esep := e.e, e.hh.hasElemSeparators()
2949         ee.WriteMapStart(len(v))
2950         if e.h.Canonical {
2951                 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
2952                 e2 := NewEncoderBytes(&mksv, e.hh)
2953                 v2 := make([]bytesI, len(v))
2954                 var i, l int
2955                 var vp *bytesI
2956                 for k2, _ := range v {
2957                         l = len(mksv)
2958                         e2.MustEncode(k2)
2959                         vp = &v2[i]
2960                         vp.v = mksv[l:]
2961                         vp.i = k2
2962                         i++
2963                 }
2964                 sort.Sort(bytesISlice(v2))
2965                 if esep {
2966                         for j := range v2 {
2967                                 ee.WriteMapElemKey()
2968                                 e.asis(v2[j].v)
2969                                 ee.WriteMapElemValue()
2970                                 e.encode(v[v2[j].i])
2971                         }
2972                 } else {
2973                         for j := range v2 {
2974                                 e.asis(v2[j].v)
2975                                 e.encode(v[v2[j].i])
2976                         }
2977                 }
2978         } else {
2979                 if esep {
2980                         for k2, v2 := range v {
2981                                 ee.WriteMapElemKey()
2982                                 e.encode(k2)
2983                                 ee.WriteMapElemValue()
2984                                 ee.EncodeInt(int64(v2))
2985                         }
2986                 } else {
2987                         for k2, v2 := range v {
2988                                 e.encode(k2)
2989                                 ee.EncodeInt(int64(v2))
2990                         }
2991                 }
2992         }
2993         ee.WriteMapEnd()
2994 }
2995
2996 func (e *Encoder) fastpathEncMapIntfFloat32R(f *codecFnInfo, rv reflect.Value) {
2997         fastpathTV.EncMapIntfFloat32V(rv2i(rv).(map[interface{}]float32), e)
2998 }
2999 func (_ fastpathT) EncMapIntfFloat32V(v map[interface{}]float32, e *Encoder) {
3000         if v == nil {
3001                 e.e.EncodeNil()
3002                 return
3003         }
3004         ee, esep := e.e, e.hh.hasElemSeparators()
3005         ee.WriteMapStart(len(v))
3006         if e.h.Canonical {
3007                 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
3008                 e2 := NewEncoderBytes(&mksv, e.hh)
3009                 v2 := make([]bytesI, len(v))
3010                 var i, l int
3011                 var vp *bytesI
3012                 for k2, _ := range v {
3013                         l = len(mksv)
3014                         e2.MustEncode(k2)
3015                         vp = &v2[i]
3016                         vp.v = mksv[l:]
3017                         vp.i = k2
3018                         i++
3019                 }
3020                 sort.Sort(bytesISlice(v2))
3021                 if esep {
3022                         for j := range v2 {
3023                                 ee.WriteMapElemKey()
3024                                 e.asis(v2[j].v)
3025                                 ee.WriteMapElemValue()
3026                                 e.encode(v[v2[j].i])
3027                         }
3028                 } else {
3029                         for j := range v2 {
3030                                 e.asis(v2[j].v)
3031                                 e.encode(v[v2[j].i])
3032                         }
3033                 }
3034         } else {
3035                 if esep {
3036                         for k2, v2 := range v {
3037                                 ee.WriteMapElemKey()
3038                                 e.encode(k2)
3039                                 ee.WriteMapElemValue()
3040                                 ee.EncodeFloat32(v2)
3041                         }
3042                 } else {
3043                         for k2, v2 := range v {
3044                                 e.encode(k2)
3045                                 ee.EncodeFloat32(v2)
3046                         }
3047                 }
3048         }
3049         ee.WriteMapEnd()
3050 }
3051
3052 func (e *Encoder) fastpathEncMapIntfFloat64R(f *codecFnInfo, rv reflect.Value) {
3053         fastpathTV.EncMapIntfFloat64V(rv2i(rv).(map[interface{}]float64), e)
3054 }
3055 func (_ fastpathT) EncMapIntfFloat64V(v map[interface{}]float64, e *Encoder) {
3056         if v == nil {
3057                 e.e.EncodeNil()
3058                 return
3059         }
3060         ee, esep := e.e, e.hh.hasElemSeparators()
3061         ee.WriteMapStart(len(v))
3062         if e.h.Canonical {
3063                 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
3064                 e2 := NewEncoderBytes(&mksv, e.hh)
3065                 v2 := make([]bytesI, len(v))
3066                 var i, l int
3067                 var vp *bytesI
3068                 for k2, _ := range v {
3069                         l = len(mksv)
3070                         e2.MustEncode(k2)
3071                         vp = &v2[i]
3072                         vp.v = mksv[l:]
3073                         vp.i = k2
3074                         i++
3075                 }
3076                 sort.Sort(bytesISlice(v2))
3077                 if esep {
3078                         for j := range v2 {
3079                                 ee.WriteMapElemKey()
3080                                 e.asis(v2[j].v)
3081                                 ee.WriteMapElemValue()
3082                                 e.encode(v[v2[j].i])
3083                         }
3084                 } else {
3085                         for j := range v2 {
3086                                 e.asis(v2[j].v)
3087                                 e.encode(v[v2[j].i])
3088                         }
3089                 }
3090         } else {
3091                 if esep {
3092                         for k2, v2 := range v {
3093                                 ee.WriteMapElemKey()
3094                                 e.encode(k2)
3095                                 ee.WriteMapElemValue()
3096                                 ee.EncodeFloat64(v2)
3097                         }
3098                 } else {
3099                         for k2, v2 := range v {
3100                                 e.encode(k2)
3101                                 ee.EncodeFloat64(v2)
3102                         }
3103                 }
3104         }
3105         ee.WriteMapEnd()
3106 }
3107
3108 func (e *Encoder) fastpathEncMapIntfBoolR(f *codecFnInfo, rv reflect.Value) {
3109         fastpathTV.EncMapIntfBoolV(rv2i(rv).(map[interface{}]bool), e)
3110 }
3111 func (_ fastpathT) EncMapIntfBoolV(v map[interface{}]bool, e *Encoder) {
3112         if v == nil {
3113                 e.e.EncodeNil()
3114                 return
3115         }
3116         ee, esep := e.e, e.hh.hasElemSeparators()
3117         ee.WriteMapStart(len(v))
3118         if e.h.Canonical {
3119                 var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
3120                 e2 := NewEncoderBytes(&mksv, e.hh)
3121                 v2 := make([]bytesI, len(v))
3122                 var i, l int
3123                 var vp *bytesI
3124                 for k2, _ := range v {
3125                         l = len(mksv)
3126                         e2.MustEncode(k2)
3127                         vp = &v2[i]
3128                         vp.v = mksv[l:]
3129                         vp.i = k2
3130                         i++
3131                 }
3132                 sort.Sort(bytesISlice(v2))
3133                 if esep {
3134                         for j := range v2 {
3135                                 ee.WriteMapElemKey()
3136                                 e.asis(v2[j].v)
3137                                 ee.WriteMapElemValue()
3138                                 e.encode(v[v2[j].i])
3139                         }
3140                 } else {
3141                         for j := range v2 {
3142                                 e.asis(v2[j].v)
3143                                 e.encode(v[v2[j].i])
3144                         }
3145                 }
3146         } else {
3147                 if esep {
3148                         for k2, v2 := range v {
3149                                 ee.WriteMapElemKey()
3150                                 e.encode(k2)
3151                                 ee.WriteMapElemValue()
3152                                 ee.EncodeBool(v2)
3153                         }
3154                 } else {
3155                         for k2, v2 := range v {
3156                                 e.encode(k2)
3157                                 ee.EncodeBool(v2)
3158                         }
3159                 }
3160         }
3161         ee.WriteMapEnd()
3162 }
3163
3164 func (e *Encoder) fastpathEncMapStringIntfR(f *codecFnInfo, rv reflect.Value) {
3165         fastpathTV.EncMapStringIntfV(rv2i(rv).(map[string]interface{}), e)
3166 }
3167 func (_ fastpathT) EncMapStringIntfV(v map[string]interface{}, e *Encoder) {
3168         if v == nil {
3169                 e.e.EncodeNil()
3170                 return
3171         }
3172         ee, esep := e.e, e.hh.hasElemSeparators()
3173         ee.WriteMapStart(len(v))
3174         if e.h.Canonical {
3175                 v2 := make([]string, len(v))
3176                 var i int
3177                 for k, _ := range v {
3178                         v2[i] = string(k)
3179                         i++
3180                 }
3181                 sort.Sort(stringSlice(v2))
3182                 if esep {
3183                         for _, k2 := range v2 {
3184                                 ee.WriteMapElemKey()
3185                                 ee.EncodeString(cUTF8, k2)
3186                                 ee.WriteMapElemValue()
3187                                 e.encode(v[string(k2)])
3188                         }
3189                 } else {
3190                         for _, k2 := range v2 {
3191                                 ee.EncodeString(cUTF8, k2)
3192                                 e.encode(v[string(k2)])
3193                         }
3194                 }
3195         } else {
3196                 if esep {
3197                         for k2, v2 := range v {
3198                                 ee.WriteMapElemKey()
3199                                 ee.EncodeString(cUTF8, k2)
3200                                 ee.WriteMapElemValue()
3201                                 e.encode(v2)
3202                         }
3203                 } else {
3204                         for k2, v2 := range v {
3205                                 ee.EncodeString(cUTF8, k2)
3206                                 e.encode(v2)
3207                         }
3208                 }
3209         }
3210         ee.WriteMapEnd()
3211 }
3212
3213 func (e *Encoder) fastpathEncMapStringStringR(f *codecFnInfo, rv reflect.Value) {
3214         fastpathTV.EncMapStringStringV(rv2i(rv).(map[string]string), e)
3215 }
3216 func (_ fastpathT) EncMapStringStringV(v map[string]string, e *Encoder) {
3217         if v == nil {
3218                 e.e.EncodeNil()
3219                 return
3220         }
3221         ee, esep := e.e, e.hh.hasElemSeparators()
3222         ee.WriteMapStart(len(v))
3223         if e.h.Canonical {
3224                 v2 := make([]string, len(v))
3225                 var i int
3226                 for k, _ := range v {
3227                         v2[i] = string(k)
3228                         i++
3229                 }
3230                 sort.Sort(stringSlice(v2))
3231                 if esep {
3232                         for _, k2 := range v2 {
3233                                 ee.WriteMapElemKey()
3234                                 ee.EncodeString(cUTF8, k2)
3235                                 ee.WriteMapElemValue()
3236                                 ee.EncodeString(cUTF8, v[string(k2)])
3237                         }
3238                 } else {
3239                         for _, k2 := range v2 {
3240                                 ee.EncodeString(cUTF8, k2)
3241                                 ee.EncodeString(cUTF8, v[string(k2)])
3242                         }
3243                 }
3244         } else {
3245                 if esep {
3246                         for k2, v2 := range v {
3247                                 ee.WriteMapElemKey()
3248                                 ee.EncodeString(cUTF8, k2)
3249                                 ee.WriteMapElemValue()
3250                                 ee.EncodeString(cUTF8, v2)
3251                         }
3252                 } else {
3253                         for k2, v2 := range v {
3254                                 ee.EncodeString(cUTF8, k2)
3255                                 ee.EncodeString(cUTF8, v2)
3256                         }
3257                 }
3258         }
3259         ee.WriteMapEnd()
3260 }
3261
3262 func (e *Encoder) fastpathEncMapStringUintR(f *codecFnInfo, rv reflect.Value) {
3263         fastpathTV.EncMapStringUintV(rv2i(rv).(map[string]uint), e)
3264 }
3265 func (_ fastpathT) EncMapStringUintV(v map[string]uint, e *Encoder) {
3266         if v == nil {
3267                 e.e.EncodeNil()
3268                 return
3269         }
3270         ee, esep := e.e, e.hh.hasElemSeparators()
3271         ee.WriteMapStart(len(v))
3272         if e.h.Canonical {
3273                 v2 := make([]string, len(v))
3274                 var i int
3275                 for k, _ := range v {
3276                         v2[i] = string(k)
3277                         i++
3278                 }
3279                 sort.Sort(stringSlice(v2))
3280                 if esep {
3281                         for _, k2 := range v2 {
3282                                 ee.WriteMapElemKey()
3283                                 ee.EncodeString(cUTF8, k2)
3284                                 ee.WriteMapElemValue()
3285                                 ee.EncodeUint(uint64(v[string(k2)]))
3286                         }
3287                 } else {
3288                         for _, k2 := range v2 {
3289                                 ee.EncodeString(cUTF8, k2)
3290                                 ee.EncodeUint(uint64(v[string(k2)]))
3291                         }
3292                 }
3293         } else {
3294                 if esep {
3295                         for k2, v2 := range v {
3296                                 ee.WriteMapElemKey()
3297                                 ee.EncodeString(cUTF8, k2)
3298                                 ee.WriteMapElemValue()
3299                                 ee.EncodeUint(uint64(v2))
3300                         }
3301                 } else {
3302                         for k2, v2 := range v {
3303                                 ee.EncodeString(cUTF8, k2)
3304                                 ee.EncodeUint(uint64(v2))
3305                         }
3306                 }
3307         }
3308         ee.WriteMapEnd()
3309 }
3310
3311 func (e *Encoder) fastpathEncMapStringUint8R(f *codecFnInfo, rv reflect.Value) {
3312         fastpathTV.EncMapStringUint8V(rv2i(rv).(map[string]uint8), e)
3313 }
3314 func (_ fastpathT) EncMapStringUint8V(v map[string]uint8, e *Encoder) {
3315         if v == nil {
3316                 e.e.EncodeNil()
3317                 return
3318         }
3319         ee, esep := e.e, e.hh.hasElemSeparators()
3320         ee.WriteMapStart(len(v))
3321         if e.h.Canonical {
3322                 v2 := make([]string, len(v))
3323                 var i int
3324                 for k, _ := range v {
3325                         v2[i] = string(k)
3326                         i++
3327                 }
3328                 sort.Sort(stringSlice(v2))
3329                 if esep {
3330                         for _, k2 := range v2 {
3331                                 ee.WriteMapElemKey()
3332                                 ee.EncodeString(cUTF8, k2)
3333                                 ee.WriteMapElemValue()
3334                                 ee.EncodeUint(uint64(v[string(k2)]))
3335                         }
3336                 } else {
3337                         for _, k2 := range v2 {
3338                                 ee.EncodeString(cUTF8, k2)
3339                                 ee.EncodeUint(uint64(v[string(k2)]))
3340                         }
3341                 }
3342         } else {
3343                 if esep {
3344                         for k2, v2 := range v {
3345                                 ee.WriteMapElemKey()
3346                                 ee.EncodeString(cUTF8, k2)
3347                                 ee.WriteMapElemValue()
3348                                 ee.EncodeUint(uint64(v2))
3349                         }
3350                 } else {
3351                         for k2, v2 := range v {
3352                                 ee.EncodeString(cUTF8, k2)
3353                                 ee.EncodeUint(uint64(v2))
3354                         }
3355                 }
3356         }
3357         ee.WriteMapEnd()
3358 }
3359
3360 func (e *Encoder) fastpathEncMapStringUint16R(f *codecFnInfo, rv reflect.Value) {
3361         fastpathTV.EncMapStringUint16V(rv2i(rv).(map[string]uint16), e)
3362 }
3363 func (_ fastpathT) EncMapStringUint16V(v map[string]uint16, e *Encoder) {
3364         if v == nil {
3365                 e.e.EncodeNil()
3366                 return
3367         }
3368         ee, esep := e.e, e.hh.hasElemSeparators()
3369         ee.WriteMapStart(len(v))
3370         if e.h.Canonical {
3371                 v2 := make([]string, len(v))
3372                 var i int
3373                 for k, _ := range v {
3374                         v2[i] = string(k)
3375                         i++
3376                 }
3377                 sort.Sort(stringSlice(v2))
3378                 if esep {
3379                         for _, k2 := range v2 {
3380                                 ee.WriteMapElemKey()
3381                                 ee.EncodeString(cUTF8, k2)
3382                                 ee.WriteMapElemValue()
3383                                 ee.EncodeUint(uint64(v[string(k2)]))
3384                         }
3385                 } else {
3386                         for _, k2 := range v2 {
3387                                 ee.EncodeString(cUTF8, k2)
3388                                 ee.EncodeUint(uint64(v[string(k2)]))
3389                         }
3390                 }
3391         } else {
3392                 if esep {
3393                         for k2, v2 := range v {
3394                                 ee.WriteMapElemKey()
3395                                 ee.EncodeString(cUTF8, k2)
3396                                 ee.WriteMapElemValue()
3397                                 ee.EncodeUint(uint64(v2))
3398                         }
3399                 } else {
3400                         for k2, v2 := range v {
3401                                 ee.EncodeString(cUTF8, k2)
3402                                 ee.EncodeUint(uint64(v2))
3403                         }
3404                 }
3405         }
3406         ee.WriteMapEnd()
3407 }
3408
3409 func (e *Encoder) fastpathEncMapStringUint32R(f *codecFnInfo, rv reflect.Value) {
3410         fastpathTV.EncMapStringUint32V(rv2i(rv).(map[string]uint32), e)
3411 }
3412 func (_ fastpathT) EncMapStringUint32V(v map[string]uint32, e *Encoder) {
3413         if v == nil {
3414                 e.e.EncodeNil()
3415                 return
3416         }
3417         ee, esep := e.e, e.hh.hasElemSeparators()
3418         ee.WriteMapStart(len(v))
3419         if e.h.Canonical {
3420                 v2 := make([]string, len(v))
3421                 var i int
3422                 for k, _ := range v {
3423                         v2[i] = string(k)
3424                         i++
3425                 }
3426                 sort.Sort(stringSlice(v2))
3427                 if esep {
3428                         for _, k2 := range v2 {
3429                                 ee.WriteMapElemKey()
3430                                 ee.EncodeString(cUTF8, k2)
3431                                 ee.WriteMapElemValue()
3432                                 ee.EncodeUint(uint64(v[string(k2)]))
3433                         }
3434                 } else {
3435                         for _, k2 := range v2 {
3436                                 ee.EncodeString(cUTF8, k2)
3437                                 ee.EncodeUint(uint64(v[string(k2)]))
3438                         }
3439                 }
3440         } else {
3441                 if esep {
3442                         for k2, v2 := range v {
3443                                 ee.WriteMapElemKey()
3444                                 ee.EncodeString(cUTF8, k2)
3445                                 ee.WriteMapElemValue()
3446                                 ee.EncodeUint(uint64(v2))
3447                         }
3448                 } else {
3449                         for k2, v2 := range v {
3450                                 ee.EncodeString(cUTF8, k2)
3451                                 ee.EncodeUint(uint64(v2))
3452                         }
3453                 }
3454         }
3455         ee.WriteMapEnd()
3456 }
3457
3458 func (e *Encoder) fastpathEncMapStringUint64R(f *codecFnInfo, rv reflect.Value) {
3459         fastpathTV.EncMapStringUint64V(rv2i(rv).(map[string]uint64), e)
3460 }
3461 func (_ fastpathT) EncMapStringUint64V(v map[string]uint64, e *Encoder) {
3462         if v == nil {
3463                 e.e.EncodeNil()
3464                 return
3465         }
3466         ee, esep := e.e, e.hh.hasElemSeparators()
3467         ee.WriteMapStart(len(v))
3468         if e.h.Canonical {
3469                 v2 := make([]string, len(v))
3470                 var i int
3471                 for k, _ := range v {
3472                         v2[i] = string(k)
3473                         i++
3474                 }
3475                 sort.Sort(stringSlice(v2))
3476                 if esep {
3477                         for _, k2 := range v2 {
3478                                 ee.WriteMapElemKey()
3479                                 ee.EncodeString(cUTF8, k2)
3480                                 ee.WriteMapElemValue()
3481                                 ee.EncodeUint(uint64(v[string(k2)]))
3482                         }
3483                 } else {
3484                         for _, k2 := range v2 {
3485                                 ee.EncodeString(cUTF8, k2)
3486                                 ee.EncodeUint(uint64(v[string(k2)]))
3487                         }
3488                 }
3489         } else {
3490                 if esep {
3491                         for k2, v2 := range v {
3492                                 ee.WriteMapElemKey()
3493                                 ee.EncodeString(cUTF8, k2)
3494                                 ee.WriteMapElemValue()
3495                                 ee.EncodeUint(uint64(v2))
3496                         }
3497                 } else {
3498                         for k2, v2 := range v {
3499                                 ee.EncodeString(cUTF8, k2)
3500                                 ee.EncodeUint(uint64(v2))
3501                         }
3502                 }
3503         }
3504         ee.WriteMapEnd()
3505 }
3506
3507 func (e *Encoder) fastpathEncMapStringUintptrR(f *codecFnInfo, rv reflect.Value) {
3508         fastpathTV.EncMapStringUintptrV(rv2i(rv).(map[string]uintptr), e)
3509 }
3510 func (_ fastpathT) EncMapStringUintptrV(v map[string]uintptr, e *Encoder) {
3511         if v == nil {
3512                 e.e.EncodeNil()
3513                 return
3514         }
3515         ee, esep := e.e, e.hh.hasElemSeparators()
3516         ee.WriteMapStart(len(v))
3517         if e.h.Canonical {
3518                 v2 := make([]string, len(v))
3519                 var i int
3520                 for k, _ := range v {
3521                         v2[i] = string(k)
3522                         i++
3523                 }
3524                 sort.Sort(stringSlice(v2))
3525                 if esep {
3526                         for _, k2 := range v2 {
3527                                 ee.WriteMapElemKey()
3528                                 ee.EncodeString(cUTF8, k2)
3529                                 ee.WriteMapElemValue()
3530                                 e.encode(v[string(k2)])
3531                         }
3532                 } else {
3533                         for _, k2 := range v2 {
3534                                 ee.EncodeString(cUTF8, k2)
3535                                 e.encode(v[string(k2)])
3536                         }
3537                 }
3538         } else {
3539                 if esep {
3540                         for k2, v2 := range v {
3541                                 ee.WriteMapElemKey()
3542                                 ee.EncodeString(cUTF8, k2)
3543                                 ee.WriteMapElemValue()
3544                                 e.encode(v2)
3545                         }
3546                 } else {
3547                         for k2, v2 := range v {
3548                                 ee.EncodeString(cUTF8, k2)
3549                                 e.encode(v2)
3550                         }
3551                 }
3552         }
3553         ee.WriteMapEnd()
3554 }
3555
3556 func (e *Encoder) fastpathEncMapStringIntR(f *codecFnInfo, rv reflect.Value) {
3557         fastpathTV.EncMapStringIntV(rv2i(rv).(map[string]int), e)
3558 }
3559 func (_ fastpathT) EncMapStringIntV(v map[string]int, e *Encoder) {
3560         if v == nil {
3561                 e.e.EncodeNil()
3562                 return
3563         }
3564         ee, esep := e.e, e.hh.hasElemSeparators()
3565         ee.WriteMapStart(len(v))
3566         if e.h.Canonical {
3567                 v2 := make([]string, len(v))
3568                 var i int
3569                 for k, _ := range v {
3570                         v2[i] = string(k)
3571                         i++
3572                 }
3573                 sort.Sort(stringSlice(v2))
3574                 if esep {
3575                         for _, k2 := range v2 {
3576                                 ee.WriteMapElemKey()
3577                                 ee.EncodeString(cUTF8, k2)
3578                                 ee.WriteMapElemValue()
3579                                 ee.EncodeInt(int64(v[string(k2)]))
3580                         }
3581                 } else {
3582                         for _, k2 := range v2 {
3583                                 ee.EncodeString(cUTF8, k2)
3584                                 ee.EncodeInt(int64(v[string(k2)]))
3585                         }
3586                 }
3587         } else {
3588                 if esep {
3589                         for k2, v2 := range v {
3590                                 ee.WriteMapElemKey()
3591                                 ee.EncodeString(cUTF8, k2)
3592                                 ee.WriteMapElemValue()
3593                                 ee.EncodeInt(int64(v2))
3594                         }
3595                 } else {
3596                         for k2, v2 := range v {
3597                                 ee.EncodeString(cUTF8, k2)
3598                                 ee.EncodeInt(int64(v2))
3599                         }
3600                 }
3601         }
3602         ee.WriteMapEnd()
3603 }
3604
3605 func (e *Encoder) fastpathEncMapStringInt8R(f *codecFnInfo, rv reflect.Value) {
3606         fastpathTV.EncMapStringInt8V(rv2i(rv).(map[string]int8), e)
3607 }
3608 func (_ fastpathT) EncMapStringInt8V(v map[string]int8, e *Encoder) {
3609         if v == nil {
3610                 e.e.EncodeNil()
3611                 return
3612         }
3613         ee, esep := e.e, e.hh.hasElemSeparators()
3614         ee.WriteMapStart(len(v))
3615         if e.h.Canonical {
3616                 v2 := make([]string, len(v))
3617                 var i int
3618                 for k, _ := range v {
3619                         v2[i] = string(k)
3620                         i++
3621                 }
3622                 sort.Sort(stringSlice(v2))
3623                 if esep {
3624                         for _, k2 := range v2 {
3625                                 ee.WriteMapElemKey()
3626                                 ee.EncodeString(cUTF8, k2)
3627                                 ee.WriteMapElemValue()
3628                                 ee.EncodeInt(int64(v[string(k2)]))
3629                         }
3630                 } else {
3631                         for _, k2 := range v2 {
3632                                 ee.EncodeString(cUTF8, k2)
3633                                 ee.EncodeInt(int64(v[string(k2)]))
3634                         }
3635                 }
3636         } else {
3637                 if esep {
3638                         for k2, v2 := range v {
3639                                 ee.WriteMapElemKey()
3640                                 ee.EncodeString(cUTF8, k2)
3641                                 ee.WriteMapElemValue()
3642                                 ee.EncodeInt(int64(v2))
3643                         }
3644                 } else {
3645                         for k2, v2 := range v {
3646                                 ee.EncodeString(cUTF8, k2)
3647                                 ee.EncodeInt(int64(v2))
3648                         }
3649                 }
3650         }
3651         ee.WriteMapEnd()
3652 }
3653
3654 func (e *Encoder) fastpathEncMapStringInt16R(f *codecFnInfo, rv reflect.Value) {
3655         fastpathTV.EncMapStringInt16V(rv2i(rv).(map[string]int16), e)
3656 }
3657 func (_ fastpathT) EncMapStringInt16V(v map[string]int16, e *Encoder) {
3658         if v == nil {
3659                 e.e.EncodeNil()
3660                 return
3661         }
3662         ee, esep := e.e, e.hh.hasElemSeparators()
3663         ee.WriteMapStart(len(v))
3664         if e.h.Canonical {
3665                 v2 := make([]string, len(v))
3666                 var i int
3667                 for k, _ := range v {
3668                         v2[i] = string(k)
3669                         i++
3670                 }
3671                 sort.Sort(stringSlice(v2))
3672                 if esep {
3673                         for _, k2 := range v2 {
3674                                 ee.WriteMapElemKey()
3675                                 ee.EncodeString(cUTF8, k2)
3676                                 ee.WriteMapElemValue()
3677                                 ee.EncodeInt(int64(v[string(k2)]))
3678                         }
3679                 } else {
3680                         for _, k2 := range v2 {
3681                                 ee.EncodeString(cUTF8, k2)
3682                                 ee.EncodeInt(int64(v[string(k2)]))
3683                         }
3684                 }
3685         } else {
3686                 if esep {
3687                         for k2, v2 := range v {
3688                                 ee.WriteMapElemKey()
3689                                 ee.EncodeString(cUTF8, k2)
3690                                 ee.WriteMapElemValue()
3691                                 ee.EncodeInt(int64(v2))
3692                         }
3693                 } else {
3694                         for k2, v2 := range v {
3695                                 ee.EncodeString(cUTF8, k2)
3696                                 ee.EncodeInt(int64(v2))
3697                         }
3698                 }
3699         }
3700         ee.WriteMapEnd()
3701 }
3702
3703 func (e *Encoder) fastpathEncMapStringInt32R(f *codecFnInfo, rv reflect.Value) {
3704         fastpathTV.EncMapStringInt32V(rv2i(rv).(map[string]int32), e)
3705 }
3706 func (_ fastpathT) EncMapStringInt32V(v map[string]int32, e *Encoder) {
3707         if v == nil {
3708                 e.e.EncodeNil()
3709                 return
3710         }
3711         ee, esep := e.e, e.hh.hasElemSeparators()
3712         ee.WriteMapStart(len(v))
3713         if e.h.Canonical {
3714                 v2 := make([]string, len(v))
3715                 var i int
3716                 for k, _ := range v {
3717                         v2[i] = string(k)
3718                         i++
3719                 }
3720                 sort.Sort(stringSlice(v2))
3721                 if esep {
3722                         for _, k2 := range v2 {
3723                                 ee.WriteMapElemKey()
3724                                 ee.EncodeString(cUTF8, k2)
3725                                 ee.WriteMapElemValue()
3726                                 ee.EncodeInt(int64(v[string(k2)]))
3727                         }
3728                 } else {
3729                         for _, k2 := range v2 {
3730                                 ee.EncodeString(cUTF8, k2)
3731                                 ee.EncodeInt(int64(v[string(k2)]))
3732                         }
3733                 }
3734         } else {
3735                 if esep {
3736                         for k2, v2 := range v {
3737                                 ee.WriteMapElemKey()
3738                                 ee.EncodeString(cUTF8, k2)
3739                                 ee.WriteMapElemValue()
3740                                 ee.EncodeInt(int64(v2))
3741                         }
3742                 } else {
3743                         for k2, v2 := range v {
3744                                 ee.EncodeString(cUTF8, k2)
3745                                 ee.EncodeInt(int64(v2))
3746                         }
3747                 }
3748         }
3749         ee.WriteMapEnd()
3750 }
3751
3752 func (e *Encoder) fastpathEncMapStringInt64R(f *codecFnInfo, rv reflect.Value) {
3753         fastpathTV.EncMapStringInt64V(rv2i(rv).(map[string]int64), e)
3754 }
3755 func (_ fastpathT) EncMapStringInt64V(v map[string]int64, e *Encoder) {
3756         if v == nil {
3757                 e.e.EncodeNil()
3758                 return
3759         }
3760         ee, esep := e.e, e.hh.hasElemSeparators()
3761         ee.WriteMapStart(len(v))
3762         if e.h.Canonical {
3763                 v2 := make([]string, len(v))
3764                 var i int
3765                 for k, _ := range v {
3766                         v2[i] = string(k)
3767                         i++
3768                 }
3769                 sort.Sort(stringSlice(v2))
3770                 if esep {
3771                         for _, k2 := range v2 {
3772                                 ee.WriteMapElemKey()
3773                                 ee.EncodeString(cUTF8, k2)
3774                                 ee.WriteMapElemValue()
3775                                 ee.EncodeInt(int64(v[string(k2)]))
3776                         }
3777                 } else {
3778                         for _, k2 := range v2 {
3779                                 ee.EncodeString(cUTF8, k2)
3780                                 ee.EncodeInt(int64(v[string(k2)]))
3781                         }
3782                 }
3783         } else {
3784                 if esep {
3785                         for k2, v2 := range v {
3786                                 ee.WriteMapElemKey()
3787                                 ee.EncodeString(cUTF8, k2)
3788                                 ee.WriteMapElemValue()
3789                                 ee.EncodeInt(int64(v2))
3790                         }
3791                 } else {
3792                         for k2, v2 := range v {
3793                                 ee.EncodeString(cUTF8, k2)
3794                                 ee.EncodeInt(int64(v2))
3795                         }
3796                 }
3797         }
3798         ee.WriteMapEnd()
3799 }
3800
3801 func (e *Encoder) fastpathEncMapStringFloat32R(f *codecFnInfo, rv reflect.Value) {
3802         fastpathTV.EncMapStringFloat32V(rv2i(rv).(map[string]float32), e)
3803 }
3804 func (_ fastpathT) EncMapStringFloat32V(v map[string]float32, e *Encoder) {
3805         if v == nil {
3806                 e.e.EncodeNil()
3807                 return
3808         }
3809         ee, esep := e.e, e.hh.hasElemSeparators()
3810         ee.WriteMapStart(len(v))
3811         if e.h.Canonical {
3812                 v2 := make([]string, len(v))
3813                 var i int
3814                 for k, _ := range v {
3815                         v2[i] = string(k)
3816                         i++
3817                 }
3818                 sort.Sort(stringSlice(v2))
3819                 if esep {
3820                         for _, k2 := range v2 {
3821                                 ee.WriteMapElemKey()
3822                                 ee.EncodeString(cUTF8, k2)
3823                                 ee.WriteMapElemValue()
3824                                 ee.EncodeFloat32(v[string(k2)])
3825                         }
3826                 } else {
3827                         for _, k2 := range v2 {
3828                                 ee.EncodeString(cUTF8, k2)
3829                                 ee.EncodeFloat32(v[string(k2)])
3830                         }
3831                 }
3832         } else {
3833                 if esep {
3834                         for k2, v2 := range v {
3835                                 ee.WriteMapElemKey()
3836                                 ee.EncodeString(cUTF8, k2)
3837                                 ee.WriteMapElemValue()
3838                                 ee.EncodeFloat32(v2)
3839                         }
3840                 } else {
3841                         for k2, v2 := range v {
3842                                 ee.EncodeString(cUTF8, k2)
3843                                 ee.EncodeFloat32(v2)
3844                         }
3845                 }
3846         }
3847         ee.WriteMapEnd()
3848 }
3849
3850 func (e *Encoder) fastpathEncMapStringFloat64R(f *codecFnInfo, rv reflect.Value) {
3851         fastpathTV.EncMapStringFloat64V(rv2i(rv).(map[string]float64), e)
3852 }
3853 func (_ fastpathT) EncMapStringFloat64V(v map[string]float64, e *Encoder) {
3854         if v == nil {
3855                 e.e.EncodeNil()
3856                 return
3857         }
3858         ee, esep := e.e, e.hh.hasElemSeparators()
3859         ee.WriteMapStart(len(v))
3860         if e.h.Canonical {
3861                 v2 := make([]string, len(v))
3862                 var i int
3863                 for k, _ := range v {
3864                         v2[i] = string(k)
3865                         i++
3866                 }
3867                 sort.Sort(stringSlice(v2))
3868                 if esep {
3869                         for _, k2 := range v2 {
3870                                 ee.WriteMapElemKey()
3871                                 ee.EncodeString(cUTF8, k2)
3872                                 ee.WriteMapElemValue()
3873                                 ee.EncodeFloat64(v[string(k2)])
3874                         }
3875                 } else {
3876                         for _, k2 := range v2 {
3877                                 ee.EncodeString(cUTF8, k2)
3878                                 ee.EncodeFloat64(v[string(k2)])
3879                         }
3880                 }
3881         } else {
3882                 if esep {
3883                         for k2, v2 := range v {
3884                                 ee.WriteMapElemKey()
3885                                 ee.EncodeString(cUTF8, k2)
3886                                 ee.WriteMapElemValue()
3887                                 ee.EncodeFloat64(v2)
3888                         }
3889                 } else {
3890                         for k2, v2 := range v {
3891                                 ee.EncodeString(cUTF8, k2)
3892                                 ee.EncodeFloat64(v2)
3893                         }
3894                 }
3895         }
3896         ee.WriteMapEnd()
3897 }
3898
3899 func (e *Encoder) fastpathEncMapStringBoolR(f *codecFnInfo, rv reflect.Value) {
3900         fastpathTV.EncMapStringBoolV(rv2i(rv).(map[string]bool), e)
3901 }
3902 func (_ fastpathT) EncMapStringBoolV(v map[string]bool, e *Encoder) {
3903         if v == nil {
3904                 e.e.EncodeNil()
3905                 return
3906         }
3907         ee, esep := e.e, e.hh.hasElemSeparators()
3908         ee.WriteMapStart(len(v))
3909         if e.h.Canonical {
3910                 v2 := make([]string, len(v))
3911                 var i int
3912                 for k, _ := range v {
3913                         v2[i] = string(k)
3914                         i++
3915                 }
3916                 sort.Sort(stringSlice(v2))
3917                 if esep {
3918                         for _, k2 := range v2 {
3919                                 ee.WriteMapElemKey()
3920                                 ee.EncodeString(cUTF8, k2)
3921                                 ee.WriteMapElemValue()
3922                                 ee.EncodeBool(v[string(k2)])
3923                         }
3924                 } else {
3925                         for _, k2 := range v2 {
3926                                 ee.EncodeString(cUTF8, k2)
3927                                 ee.EncodeBool(v[string(k2)])
3928                         }
3929                 }
3930         } else {
3931                 if esep {
3932                         for k2, v2 := range v {
3933                                 ee.WriteMapElemKey()
3934                                 ee.EncodeString(cUTF8, k2)
3935                                 ee.WriteMapElemValue()
3936                                 ee.EncodeBool(v2)
3937                         }
3938                 } else {
3939                         for k2, v2 := range v {
3940                                 ee.EncodeString(cUTF8, k2)
3941                                 ee.EncodeBool(v2)
3942                         }
3943                 }
3944         }
3945         ee.WriteMapEnd()
3946 }
3947
3948 func (e *Encoder) fastpathEncMapFloat32IntfR(f *codecFnInfo, rv reflect.Value) {
3949         fastpathTV.EncMapFloat32IntfV(rv2i(rv).(map[float32]interface{}), e)
3950 }
3951 func (_ fastpathT) EncMapFloat32IntfV(v map[float32]interface{}, e *Encoder) {
3952         if v == nil {
3953                 e.e.EncodeNil()
3954                 return
3955         }
3956         ee, esep := e.e, e.hh.hasElemSeparators()
3957         ee.WriteMapStart(len(v))
3958         if e.h.Canonical {
3959                 v2 := make([]float64, len(v))
3960                 var i int
3961                 for k, _ := range v {
3962                         v2[i] = float64(k)
3963                         i++
3964                 }
3965                 sort.Sort(floatSlice(v2))
3966                 if esep {
3967                         for _, k2 := range v2 {
3968                                 ee.WriteMapElemKey()
3969                                 ee.EncodeFloat32(float32(k2))
3970                                 ee.WriteMapElemValue()
3971                                 e.encode(v[float32(k2)])
3972                         }
3973                 } else {
3974                         for _, k2 := range v2 {
3975                                 ee.EncodeFloat32(float32(k2))
3976                                 e.encode(v[float32(k2)])
3977                         }
3978                 }
3979         } else {
3980                 if esep {
3981                         for k2, v2 := range v {
3982                                 ee.WriteMapElemKey()
3983                                 ee.EncodeFloat32(k2)
3984                                 ee.WriteMapElemValue()
3985                                 e.encode(v2)
3986                         }
3987                 } else {
3988                         for k2, v2 := range v {
3989                                 ee.EncodeFloat32(k2)
3990                                 e.encode(v2)
3991                         }
3992                 }
3993         }
3994         ee.WriteMapEnd()
3995 }
3996
3997 func (e *Encoder) fastpathEncMapFloat32StringR(f *codecFnInfo, rv reflect.Value) {
3998         fastpathTV.EncMapFloat32StringV(rv2i(rv).(map[float32]string), e)
3999 }
4000 func (_ fastpathT) EncMapFloat32StringV(v map[float32]string, e *Encoder) {
4001         if v == nil {
4002                 e.e.EncodeNil()
4003                 return
4004         }
4005         ee, esep := e.e, e.hh.hasElemSeparators()
4006         ee.WriteMapStart(len(v))
4007         if e.h.Canonical {
4008                 v2 := make([]float64, len(v))
4009                 var i int
4010                 for k, _ := range v {
4011                         v2[i] = float64(k)
4012                         i++
4013                 }
4014                 sort.Sort(floatSlice(v2))
4015                 if esep {
4016                         for _, k2 := range v2 {
4017                                 ee.WriteMapElemKey()
4018                                 ee.EncodeFloat32(float32(k2))
4019                                 ee.WriteMapElemValue()
4020                                 ee.EncodeString(cUTF8, v[float32(k2)])
4021                         }
4022                 } else {
4023                         for _, k2 := range v2 {
4024                                 ee.EncodeFloat32(float32(k2))
4025                                 ee.EncodeString(cUTF8, v[float32(k2)])
4026                         }
4027                 }
4028         } else {
4029                 if esep {
4030                         for k2, v2 := range v {
4031                                 ee.WriteMapElemKey()
4032                                 ee.EncodeFloat32(k2)
4033                                 ee.WriteMapElemValue()
4034                                 ee.EncodeString(cUTF8, v2)
4035                         }
4036                 } else {
4037                         for k2, v2 := range v {
4038                                 ee.EncodeFloat32(k2)
4039                                 ee.EncodeString(cUTF8, v2)
4040                         }
4041                 }
4042         }
4043         ee.WriteMapEnd()
4044 }
4045
4046 func (e *Encoder) fastpathEncMapFloat32UintR(f *codecFnInfo, rv reflect.Value) {
4047         fastpathTV.EncMapFloat32UintV(rv2i(rv).(map[float32]uint), e)
4048 }
4049 func (_ fastpathT) EncMapFloat32UintV(v map[float32]uint, e *Encoder) {
4050         if v == nil {
4051                 e.e.EncodeNil()
4052                 return
4053         }
4054         ee, esep := e.e, e.hh.hasElemSeparators()
4055         ee.WriteMapStart(len(v))
4056         if e.h.Canonical {
4057                 v2 := make([]float64, len(v))
4058                 var i int
4059                 for k, _ := range v {
4060                         v2[i] = float64(k)
4061                         i++
4062                 }
4063                 sort.Sort(floatSlice(v2))
4064                 if esep {
4065                         for _, k2 := range v2 {
4066                                 ee.WriteMapElemKey()
4067                                 ee.EncodeFloat32(float32(k2))
4068                                 ee.WriteMapElemValue()
4069                                 ee.EncodeUint(uint64(v[float32(k2)]))
4070                         }
4071                 } else {
4072                         for _, k2 := range v2 {
4073                                 ee.EncodeFloat32(float32(k2))
4074                                 ee.EncodeUint(uint64(v[float32(k2)]))
4075                         }
4076                 }
4077         } else {
4078                 if esep {
4079                         for k2, v2 := range v {
4080                                 ee.WriteMapElemKey()
4081                                 ee.EncodeFloat32(k2)
4082                                 ee.WriteMapElemValue()
4083                                 ee.EncodeUint(uint64(v2))
4084                         }
4085                 } else {
4086                         for k2, v2 := range v {
4087                                 ee.EncodeFloat32(k2)
4088                                 ee.EncodeUint(uint64(v2))
4089                         }
4090                 }
4091         }
4092         ee.WriteMapEnd()
4093 }
4094
4095 func (e *Encoder) fastpathEncMapFloat32Uint8R(f *codecFnInfo, rv reflect.Value) {
4096         fastpathTV.EncMapFloat32Uint8V(rv2i(rv).(map[float32]uint8), e)
4097 }
4098 func (_ fastpathT) EncMapFloat32Uint8V(v map[float32]uint8, e *Encoder) {
4099         if v == nil {
4100                 e.e.EncodeNil()
4101                 return
4102         }
4103         ee, esep := e.e, e.hh.hasElemSeparators()
4104         ee.WriteMapStart(len(v))
4105         if e.h.Canonical {
4106                 v2 := make([]float64, len(v))
4107                 var i int
4108                 for k, _ := range v {
4109                         v2[i] = float64(k)
4110                         i++
4111                 }
4112                 sort.Sort(floatSlice(v2))
4113                 if esep {
4114                         for _, k2 := range v2 {
4115                                 ee.WriteMapElemKey()
4116                                 ee.EncodeFloat32(float32(k2))
4117                                 ee.WriteMapElemValue()
4118                                 ee.EncodeUint(uint64(v[float32(k2)]))
4119                         }
4120                 } else {
4121                         for _, k2 := range v2 {
4122                                 ee.EncodeFloat32(float32(k2))
4123                                 ee.EncodeUint(uint64(v[float32(k2)]))
4124                         }
4125                 }
4126         } else {
4127                 if esep {
4128                         for k2, v2 := range v {
4129                                 ee.WriteMapElemKey()
4130                                 ee.EncodeFloat32(k2)
4131                                 ee.WriteMapElemValue()
4132                                 ee.EncodeUint(uint64(v2))
4133                         }
4134                 } else {
4135                         for k2, v2 := range v {
4136                                 ee.EncodeFloat32(k2)
4137                                 ee.EncodeUint(uint64(v2))
4138                         }
4139                 }
4140         }
4141         ee.WriteMapEnd()
4142 }
4143
4144 func (e *Encoder) fastpathEncMapFloat32Uint16R(f *codecFnInfo, rv reflect.Value) {
4145         fastpathTV.EncMapFloat32Uint16V(rv2i(rv).(map[float32]uint16), e)
4146 }
4147 func (_ fastpathT) EncMapFloat32Uint16V(v map[float32]uint16, e *Encoder) {
4148         if v == nil {
4149                 e.e.EncodeNil()
4150                 return
4151         }
4152         ee, esep := e.e, e.hh.hasElemSeparators()
4153         ee.WriteMapStart(len(v))
4154         if e.h.Canonical {
4155                 v2 := make([]float64, len(v))
4156                 var i int
4157                 for k, _ := range v {
4158                         v2[i] = float64(k)
4159                         i++
4160                 }
4161                 sort.Sort(floatSlice(v2))
4162                 if esep {
4163                         for _, k2 := range v2 {
4164                                 ee.WriteMapElemKey()
4165                                 ee.EncodeFloat32(float32(k2))
4166                                 ee.WriteMapElemValue()
4167                                 ee.EncodeUint(uint64(v[float32(k2)]))
4168                         }
4169                 } else {
4170                         for _, k2 := range v2 {
4171                                 ee.EncodeFloat32(float32(k2))
4172                                 ee.EncodeUint(uint64(v[float32(k2)]))
4173                         }
4174                 }
4175         } else {
4176                 if esep {
4177                         for k2, v2 := range v {
4178                                 ee.WriteMapElemKey()
4179                                 ee.EncodeFloat32(k2)
4180                                 ee.WriteMapElemValue()
4181                                 ee.EncodeUint(uint64(v2))
4182                         }
4183                 } else {
4184                         for k2, v2 := range v {
4185                                 ee.EncodeFloat32(k2)
4186                                 ee.EncodeUint(uint64(v2))
4187                         }
4188                 }
4189         }
4190         ee.WriteMapEnd()
4191 }
4192
4193 func (e *Encoder) fastpathEncMapFloat32Uint32R(f *codecFnInfo, rv reflect.Value) {
4194         fastpathTV.EncMapFloat32Uint32V(rv2i(rv).(map[float32]uint32), e)
4195 }
4196 func (_ fastpathT) EncMapFloat32Uint32V(v map[float32]uint32, e *Encoder) {
4197         if v == nil {
4198                 e.e.EncodeNil()
4199                 return
4200         }
4201         ee, esep := e.e, e.hh.hasElemSeparators()
4202         ee.WriteMapStart(len(v))
4203         if e.h.Canonical {
4204                 v2 := make([]float64, len(v))
4205                 var i int
4206                 for k, _ := range v {
4207                         v2[i] = float64(k)
4208                         i++
4209                 }
4210                 sort.Sort(floatSlice(v2))
4211                 if esep {
4212                         for _, k2 := range v2 {
4213                                 ee.WriteMapElemKey()
4214                                 ee.EncodeFloat32(float32(k2))
4215                                 ee.WriteMapElemValue()
4216                                 ee.EncodeUint(uint64(v[float32(k2)]))
4217                         }
4218                 } else {
4219                         for _, k2 := range v2 {
4220                                 ee.EncodeFloat32(float32(k2))
4221                                 ee.EncodeUint(uint64(v[float32(k2)]))
4222                         }
4223                 }
4224         } else {
4225                 if esep {
4226                         for k2, v2 := range v {
4227                                 ee.WriteMapElemKey()
4228                                 ee.EncodeFloat32(k2)
4229                                 ee.WriteMapElemValue()
4230                                 ee.EncodeUint(uint64(v2))
4231                         }
4232                 } else {
4233                         for k2, v2 := range v {
4234                                 ee.EncodeFloat32(k2)
4235                                 ee.EncodeUint(uint64(v2))
4236                         }
4237                 }
4238         }
4239         ee.WriteMapEnd()
4240 }
4241
4242 func (e *Encoder) fastpathEncMapFloat32Uint64R(f *codecFnInfo, rv reflect.Value) {
4243         fastpathTV.EncMapFloat32Uint64V(rv2i(rv).(map[float32]uint64), e)
4244 }
4245 func (_ fastpathT) EncMapFloat32Uint64V(v map[float32]uint64, e *Encoder) {
4246         if v == nil {
4247                 e.e.EncodeNil()
4248                 return
4249         }
4250         ee, esep := e.e, e.hh.hasElemSeparators()
4251         ee.WriteMapStart(len(v))
4252         if e.h.Canonical {
4253                 v2 := make([]float64, len(v))
4254                 var i int
4255                 for k, _ := range v {
4256                         v2[i] = float64(k)
4257                         i++
4258                 }
4259                 sort.Sort(floatSlice(v2))
4260                 if esep {
4261                         for _, k2 := range v2 {
4262                                 ee.WriteMapElemKey()
4263                                 ee.EncodeFloat32(float32(k2))
4264                                 ee.WriteMapElemValue()
4265                                 ee.EncodeUint(uint64(v[float32(k2)]))
4266                         }
4267                 } else {
4268                         for _, k2 := range v2 {
4269                                 ee.EncodeFloat32(float32(k2))
4270                                 ee.EncodeUint(uint64(v[float32(k2)]))
4271                         }
4272                 }
4273         } else {
4274                 if esep {
4275                         for k2, v2 := range v {
4276                                 ee.WriteMapElemKey()
4277                                 ee.EncodeFloat32(k2)
4278                                 ee.WriteMapElemValue()
4279                                 ee.EncodeUint(uint64(v2))
4280                         }
4281                 } else {
4282                         for k2, v2 := range v {
4283                                 ee.EncodeFloat32(k2)
4284                                 ee.EncodeUint(uint64(v2))
4285                         }
4286                 }
4287         }
4288         ee.WriteMapEnd()
4289 }
4290
4291 func (e *Encoder) fastpathEncMapFloat32UintptrR(f *codecFnInfo, rv reflect.Value) {
4292         fastpathTV.EncMapFloat32UintptrV(rv2i(rv).(map[float32]uintptr), e)
4293 }
4294 func (_ fastpathT) EncMapFloat32UintptrV(v map[float32]uintptr, e *Encoder) {
4295         if v == nil {
4296                 e.e.EncodeNil()
4297                 return
4298         }
4299         ee, esep := e.e, e.hh.hasElemSeparators()
4300         ee.WriteMapStart(len(v))
4301         if e.h.Canonical {
4302                 v2 := make([]float64, len(v))
4303                 var i int
4304                 for k, _ := range v {
4305                         v2[i] = float64(k)
4306                         i++
4307                 }
4308                 sort.Sort(floatSlice(v2))
4309                 if esep {
4310                         for _, k2 := range v2 {
4311                                 ee.WriteMapElemKey()
4312                                 ee.EncodeFloat32(float32(k2))
4313                                 ee.WriteMapElemValue()
4314                                 e.encode(v[float32(k2)])
4315                         }
4316                 } else {
4317                         for _, k2 := range v2 {
4318                                 ee.EncodeFloat32(float32(k2))
4319                                 e.encode(v[float32(k2)])
4320                         }
4321                 }
4322         } else {
4323                 if esep {
4324                         for k2, v2 := range v {
4325                                 ee.WriteMapElemKey()
4326                                 ee.EncodeFloat32(k2)
4327                                 ee.WriteMapElemValue()
4328                                 e.encode(v2)
4329                         }
4330                 } else {
4331                         for k2, v2 := range v {
4332                                 ee.EncodeFloat32(k2)
4333                                 e.encode(v2)
4334                         }
4335                 }
4336         }
4337         ee.WriteMapEnd()
4338 }
4339
4340 func (e *Encoder) fastpathEncMapFloat32IntR(f *codecFnInfo, rv reflect.Value) {
4341         fastpathTV.EncMapFloat32IntV(rv2i(rv).(map[float32]int), e)
4342 }
4343 func (_ fastpathT) EncMapFloat32IntV(v map[float32]int, e *Encoder) {
4344         if v == nil {
4345                 e.e.EncodeNil()
4346                 return
4347         }
4348         ee, esep := e.e, e.hh.hasElemSeparators()
4349         ee.WriteMapStart(len(v))
4350         if e.h.Canonical {
4351                 v2 := make([]float64, len(v))
4352                 var i int
4353                 for k, _ := range v {
4354                         v2[i] = float64(k)
4355                         i++
4356                 }
4357                 sort.Sort(floatSlice(v2))
4358                 if esep {
4359                         for _, k2 := range v2 {
4360                                 ee.WriteMapElemKey()
4361                                 ee.EncodeFloat32(float32(k2))
4362                                 ee.WriteMapElemValue()
4363                                 ee.EncodeInt(int64(v[float32(k2)]))
4364                         }
4365                 } else {
4366                         for _, k2 := range v2 {
4367                                 ee.EncodeFloat32(float32(k2))
4368                                 ee.EncodeInt(int64(v[float32(k2)]))
4369                         }
4370                 }
4371         } else {
4372                 if esep {
4373                         for k2, v2 := range v {
4374                                 ee.WriteMapElemKey()
4375                                 ee.EncodeFloat32(k2)
4376                                 ee.WriteMapElemValue()
4377                                 ee.EncodeInt(int64(v2))
4378                         }
4379                 } else {
4380                         for k2, v2 := range v {
4381                                 ee.EncodeFloat32(k2)
4382                                 ee.EncodeInt(int64(v2))
4383                         }
4384                 }
4385         }
4386         ee.WriteMapEnd()
4387 }
4388
4389 func (e *Encoder) fastpathEncMapFloat32Int8R(f *codecFnInfo, rv reflect.Value) {
4390         fastpathTV.EncMapFloat32Int8V(rv2i(rv).(map[float32]int8), e)
4391 }
4392 func (_ fastpathT) EncMapFloat32Int8V(v map[float32]int8, e *Encoder) {
4393         if v == nil {
4394                 e.e.EncodeNil()
4395                 return
4396         }
4397         ee, esep := e.e, e.hh.hasElemSeparators()
4398         ee.WriteMapStart(len(v))
4399         if e.h.Canonical {
4400                 v2 := make([]float64, len(v))
4401                 var i int
4402                 for k, _ := range v {
4403                         v2[i] = float64(k)
4404                         i++
4405                 }
4406                 sort.Sort(floatSlice(v2))
4407                 if esep {
4408                         for _, k2 := range v2 {
4409                                 ee.WriteMapElemKey()
4410                                 ee.EncodeFloat32(float32(k2))
4411                                 ee.WriteMapElemValue()
4412                                 ee.EncodeInt(int64(v[float32(k2)]))
4413                         }
4414                 } else {
4415                         for _, k2 := range v2 {
4416                                 ee.EncodeFloat32(float32(k2))
4417                                 ee.EncodeInt(int64(v[float32(k2)]))
4418                         }
4419                 }
4420         } else {
4421                 if esep {
4422                         for k2, v2 := range v {
4423                                 ee.WriteMapElemKey()
4424                                 ee.EncodeFloat32(k2)
4425                                 ee.WriteMapElemValue()
4426                                 ee.EncodeInt(int64(v2))
4427                         }
4428                 } else {
4429                         for k2, v2 := range v {
4430                                 ee.EncodeFloat32(k2)
4431                                 ee.EncodeInt(int64(v2))
4432                         }
4433                 }
4434         }
4435         ee.WriteMapEnd()
4436 }
4437
4438 func (e *Encoder) fastpathEncMapFloat32Int16R(f *codecFnInfo, rv reflect.Value) {
4439         fastpathTV.EncMapFloat32Int16V(rv2i(rv).(map[float32]int16), e)
4440 }
4441 func (_ fastpathT) EncMapFloat32Int16V(v map[float32]int16, e *Encoder) {
4442         if v == nil {
4443                 e.e.EncodeNil()
4444                 return
4445         }
4446         ee, esep := e.e, e.hh.hasElemSeparators()
4447         ee.WriteMapStart(len(v))
4448         if e.h.Canonical {
4449                 v2 := make([]float64, len(v))
4450                 var i int
4451                 for k, _ := range v {
4452                         v2[i] = float64(k)
4453                         i++
4454                 }
4455                 sort.Sort(floatSlice(v2))
4456                 if esep {
4457                         for _, k2 := range v2 {
4458                                 ee.WriteMapElemKey()
4459                                 ee.EncodeFloat32(float32(k2))
4460                                 ee.WriteMapElemValue()
4461                                 ee.EncodeInt(int64(v[float32(k2)]))
4462                         }
4463                 } else {
4464                         for _, k2 := range v2 {
4465                                 ee.EncodeFloat32(float32(k2))
4466                                 ee.EncodeInt(int64(v[float32(k2)]))
4467                         }
4468                 }
4469         } else {
4470                 if esep {
4471                         for k2, v2 := range v {
4472                                 ee.WriteMapElemKey()
4473                                 ee.EncodeFloat32(k2)
4474                                 ee.WriteMapElemValue()
4475                                 ee.EncodeInt(int64(v2))
4476                         }
4477                 } else {
4478                         for k2, v2 := range v {
4479                                 ee.EncodeFloat32(k2)
4480                                 ee.EncodeInt(int64(v2))
4481                         }
4482                 }
4483         }
4484         ee.WriteMapEnd()
4485 }
4486
4487 func (e *Encoder) fastpathEncMapFloat32Int32R(f *codecFnInfo, rv reflect.Value) {
4488         fastpathTV.EncMapFloat32Int32V(rv2i(rv).(map[float32]int32), e)
4489 }
4490 func (_ fastpathT) EncMapFloat32Int32V(v map[float32]int32, e *Encoder) {
4491         if v == nil {
4492                 e.e.EncodeNil()
4493                 return
4494         }
4495         ee, esep := e.e, e.hh.hasElemSeparators()
4496         ee.WriteMapStart(len(v))
4497         if e.h.Canonical {
4498                 v2 := make([]float64, len(v))
4499                 var i int
4500                 for k, _ := range v {
4501                         v2[i] = float64(k)
4502                         i++
4503                 }
4504                 sort.Sort(floatSlice(v2))
4505                 if esep {
4506                         for _, k2 := range v2 {
4507                                 ee.WriteMapElemKey()
4508                                 ee.EncodeFloat32(float32(k2))
4509                                 ee.WriteMapElemValue()
4510                                 ee.EncodeInt(int64(v[float32(k2)]))
4511                         }
4512                 } else {
4513                         for _, k2 := range v2 {
4514                                 ee.EncodeFloat32(float32(k2))
4515                                 ee.EncodeInt(int64(v[float32(k2)]))
4516                         }
4517                 }
4518         } else {
4519                 if esep {
4520                         for k2, v2 := range v {
4521                                 ee.WriteMapElemKey()
4522                                 ee.EncodeFloat32(k2)
4523                                 ee.WriteMapElemValue()
4524                                 ee.EncodeInt(int64(v2))
4525                         }
4526                 } else {
4527                         for k2, v2 := range v {
4528                                 ee.EncodeFloat32(k2)
4529                                 ee.EncodeInt(int64(v2))
4530                         }
4531                 }
4532         }
4533         ee.WriteMapEnd()
4534 }
4535
4536 func (e *Encoder) fastpathEncMapFloat32Int64R(f *codecFnInfo, rv reflect.Value) {
4537         fastpathTV.EncMapFloat32Int64V(rv2i(rv).(map[float32]int64), e)
4538 }
4539 func (_ fastpathT) EncMapFloat32Int64V(v map[float32]int64, e *Encoder) {
4540         if v == nil {
4541                 e.e.EncodeNil()
4542                 return
4543         }
4544         ee, esep := e.e, e.hh.hasElemSeparators()
4545         ee.WriteMapStart(len(v))
4546         if e.h.Canonical {
4547                 v2 := make([]float64, len(v))
4548                 var i int
4549                 for k, _ := range v {
4550                         v2[i] = float64(k)
4551                         i++
4552                 }
4553                 sort.Sort(floatSlice(v2))
4554                 if esep {
4555                         for _, k2 := range v2 {
4556                                 ee.WriteMapElemKey()
4557                                 ee.EncodeFloat32(float32(k2))
4558                                 ee.WriteMapElemValue()
4559                                 ee.EncodeInt(int64(v[float32(k2)]))
4560                         }
4561                 } else {
4562                         for _, k2 := range v2 {
4563                                 ee.EncodeFloat32(float32(k2))
4564                                 ee.EncodeInt(int64(v[float32(k2)]))
4565                         }
4566                 }
4567         } else {
4568                 if esep {
4569                         for k2, v2 := range v {
4570                                 ee.WriteMapElemKey()
4571                                 ee.EncodeFloat32(k2)
4572                                 ee.WriteMapElemValue()
4573                                 ee.EncodeInt(int64(v2))
4574                         }
4575                 } else {
4576                         for k2, v2 := range v {
4577                                 ee.EncodeFloat32(k2)
4578                                 ee.EncodeInt(int64(v2))
4579                         }
4580                 }
4581         }
4582         ee.WriteMapEnd()
4583 }
4584
4585 func (e *Encoder) fastpathEncMapFloat32Float32R(f *codecFnInfo, rv reflect.Value) {
4586         fastpathTV.EncMapFloat32Float32V(rv2i(rv).(map[float32]float32), e)
4587 }
4588 func (_ fastpathT) EncMapFloat32Float32V(v map[float32]float32, e *Encoder) {
4589         if v == nil {
4590                 e.e.EncodeNil()
4591                 return
4592         }
4593         ee, esep := e.e, e.hh.hasElemSeparators()
4594         ee.WriteMapStart(len(v))
4595         if e.h.Canonical {
4596                 v2 := make([]float64, len(v))
4597                 var i int
4598                 for k, _ := range v {
4599                         v2[i] = float64(k)
4600                         i++
4601                 }
4602                 sort.Sort(floatSlice(v2))
4603                 if esep {
4604                         for _, k2 := range v2 {
4605                                 ee.WriteMapElemKey()
4606                                 ee.EncodeFloat32(float32(k2))
4607                                 ee.WriteMapElemValue()
4608                                 ee.EncodeFloat32(v[float32(k2)])
4609                         }
4610                 } else {
4611                         for _, k2 := range v2 {
4612                                 ee.EncodeFloat32(float32(k2))
4613                                 ee.EncodeFloat32(v[float32(k2)])
4614                         }
4615                 }
4616         } else {
4617                 if esep {
4618                         for k2, v2 := range v {
4619                                 ee.WriteMapElemKey()
4620                                 ee.EncodeFloat32(k2)
4621                                 ee.WriteMapElemValue()
4622                                 ee.EncodeFloat32(v2)
4623                         }
4624                 } else {
4625                         for k2, v2 := range v {
4626                                 ee.EncodeFloat32(k2)
4627                                 ee.EncodeFloat32(v2)
4628                         }
4629                 }
4630         }
4631         ee.WriteMapEnd()
4632 }
4633
4634 func (e *Encoder) fastpathEncMapFloat32Float64R(f *codecFnInfo, rv reflect.Value) {
4635         fastpathTV.EncMapFloat32Float64V(rv2i(rv).(map[float32]float64), e)
4636 }
4637 func (_ fastpathT) EncMapFloat32Float64V(v map[float32]float64, e *Encoder) {
4638         if v == nil {
4639                 e.e.EncodeNil()
4640                 return
4641         }
4642         ee, esep := e.e, e.hh.hasElemSeparators()
4643         ee.WriteMapStart(len(v))
4644         if e.h.Canonical {
4645                 v2 := make([]float64, len(v))
4646                 var i int
4647                 for k, _ := range v {
4648                         v2[i] = float64(k)
4649                         i++
4650                 }
4651                 sort.Sort(floatSlice(v2))
4652                 if esep {
4653                         for _, k2 := range v2 {
4654                                 ee.WriteMapElemKey()
4655                                 ee.EncodeFloat32(float32(k2))
4656                                 ee.WriteMapElemValue()
4657                                 ee.EncodeFloat64(v[float32(k2)])
4658                         }
4659                 } else {
4660                         for _, k2 := range v2 {
4661                                 ee.EncodeFloat32(float32(k2))
4662                                 ee.EncodeFloat64(v[float32(k2)])
4663                         }
4664                 }
4665         } else {
4666                 if esep {
4667                         for k2, v2 := range v {
4668                                 ee.WriteMapElemKey()
4669                                 ee.EncodeFloat32(k2)
4670                                 ee.WriteMapElemValue()
4671                                 ee.EncodeFloat64(v2)
4672                         }
4673                 } else {
4674                         for k2, v2 := range v {
4675                                 ee.EncodeFloat32(k2)
4676                                 ee.EncodeFloat64(v2)
4677                         }
4678                 }
4679         }
4680         ee.WriteMapEnd()
4681 }
4682
4683 func (e *Encoder) fastpathEncMapFloat32BoolR(f *codecFnInfo, rv reflect.Value) {
4684         fastpathTV.EncMapFloat32BoolV(rv2i(rv).(map[float32]bool), e)
4685 }
4686 func (_ fastpathT) EncMapFloat32BoolV(v map[float32]bool, e *Encoder) {
4687         if v == nil {
4688                 e.e.EncodeNil()
4689                 return
4690         }
4691         ee, esep := e.e, e.hh.hasElemSeparators()
4692         ee.WriteMapStart(len(v))
4693         if e.h.Canonical {
4694                 v2 := make([]float64, len(v))
4695                 var i int
4696                 for k, _ := range v {
4697                         v2[i] = float64(k)
4698                         i++
4699                 }
4700                 sort.Sort(floatSlice(v2))
4701                 if esep {
4702                         for _, k2 := range v2 {
4703                                 ee.WriteMapElemKey()
4704                                 ee.EncodeFloat32(float32(k2))
4705                                 ee.WriteMapElemValue()
4706                                 ee.EncodeBool(v[float32(k2)])
4707                         }
4708                 } else {
4709                         for _, k2 := range v2 {
4710                                 ee.EncodeFloat32(float32(k2))
4711                                 ee.EncodeBool(v[float32(k2)])
4712                         }
4713                 }
4714         } else {
4715                 if esep {
4716                         for k2, v2 := range v {
4717                                 ee.WriteMapElemKey()
4718                                 ee.EncodeFloat32(k2)
4719                                 ee.WriteMapElemValue()
4720                                 ee.EncodeBool(v2)
4721                         }
4722                 } else {
4723                         for k2, v2 := range v {
4724                                 ee.EncodeFloat32(k2)
4725                                 ee.EncodeBool(v2)
4726                         }
4727                 }
4728         }
4729         ee.WriteMapEnd()
4730 }
4731
4732 func (e *Encoder) fastpathEncMapFloat64IntfR(f *codecFnInfo, rv reflect.Value) {
4733         fastpathTV.EncMapFloat64IntfV(rv2i(rv).(map[float64]interface{}), e)
4734 }
4735 func (_ fastpathT) EncMapFloat64IntfV(v map[float64]interface{}, e *Encoder) {
4736         if v == nil {
4737                 e.e.EncodeNil()
4738                 return
4739         }
4740         ee, esep := e.e, e.hh.hasElemSeparators()
4741         ee.WriteMapStart(len(v))
4742         if e.h.Canonical {
4743                 v2 := make([]float64, len(v))
4744                 var i int
4745                 for k, _ := range v {
4746                         v2[i] = float64(k)
4747                         i++
4748                 }
4749                 sort.Sort(floatSlice(v2))
4750                 if esep {
4751                         for _, k2 := range v2 {
4752                                 ee.WriteMapElemKey()
4753                                 ee.EncodeFloat64(float64(k2))
4754                                 ee.WriteMapElemValue()
4755                                 e.encode(v[float64(k2)])
4756                         }
4757                 } else {
4758                         for _, k2 := range v2 {
4759                                 ee.EncodeFloat64(float64(k2))
4760                                 e.encode(v[float64(k2)])
4761                         }
4762                 }
4763         } else {
4764                 if esep {
4765                         for k2, v2 := range v {
4766                                 ee.WriteMapElemKey()
4767                                 ee.EncodeFloat64(k2)
4768                                 ee.WriteMapElemValue()
4769                                 e.encode(v2)
4770                         }
4771                 } else {
4772                         for k2, v2 := range v {
4773                                 ee.EncodeFloat64(k2)
4774                                 e.encode(v2)
4775                         }
4776                 }
4777         }
4778         ee.WriteMapEnd()
4779 }
4780
4781 func (e *Encoder) fastpathEncMapFloat64StringR(f *codecFnInfo, rv reflect.Value) {
4782         fastpathTV.EncMapFloat64StringV(rv2i(rv).(map[float64]string), e)
4783 }
4784 func (_ fastpathT) EncMapFloat64StringV(v map[float64]string, e *Encoder) {
4785         if v == nil {
4786                 e.e.EncodeNil()
4787                 return
4788         }
4789         ee, esep := e.e, e.hh.hasElemSeparators()
4790         ee.WriteMapStart(len(v))
4791         if e.h.Canonical {
4792                 v2 := make([]float64, len(v))
4793                 var i int
4794                 for k, _ := range v {
4795                         v2[i] = float64(k)
4796                         i++
4797                 }
4798                 sort.Sort(floatSlice(v2))
4799                 if esep {
4800                         for _, k2 := range v2 {
4801                                 ee.WriteMapElemKey()
4802                                 ee.EncodeFloat64(float64(k2))
4803                                 ee.WriteMapElemValue()
4804                                 ee.EncodeString(cUTF8, v[float64(k2)])
4805                         }
4806                 } else {
4807                         for _, k2 := range v2 {
4808                                 ee.EncodeFloat64(float64(k2))
4809                                 ee.EncodeString(cUTF8, v[float64(k2)])
4810                         }
4811                 }
4812         } else {
4813                 if esep {
4814                         for k2, v2 := range v {
4815                                 ee.WriteMapElemKey()
4816                                 ee.EncodeFloat64(k2)
4817                                 ee.WriteMapElemValue()
4818                                 ee.EncodeString(cUTF8, v2)
4819                         }
4820                 } else {
4821                         for k2, v2 := range v {
4822                                 ee.EncodeFloat64(k2)
4823                                 ee.EncodeString(cUTF8, v2)
4824                         }
4825                 }
4826         }
4827         ee.WriteMapEnd()
4828 }
4829
4830 func (e *Encoder) fastpathEncMapFloat64UintR(f *codecFnInfo, rv reflect.Value) {
4831         fastpathTV.EncMapFloat64UintV(rv2i(rv).(map[float64]uint), e)
4832 }
4833 func (_ fastpathT) EncMapFloat64UintV(v map[float64]uint, e *Encoder) {
4834         if v == nil {
4835                 e.e.EncodeNil()
4836                 return
4837         }
4838         ee, esep := e.e, e.hh.hasElemSeparators()
4839         ee.WriteMapStart(len(v))
4840         if e.h.Canonical {
4841                 v2 := make([]float64, len(v))
4842                 var i int
4843                 for k, _ := range v {
4844                         v2[i] = float64(k)
4845                         i++
4846                 }
4847                 sort.Sort(floatSlice(v2))
4848                 if esep {
4849                         for _, k2 := range v2 {
4850                                 ee.WriteMapElemKey()
4851                                 ee.EncodeFloat64(float64(k2))
4852                                 ee.WriteMapElemValue()
4853                                 ee.EncodeUint(uint64(v[float64(k2)]))
4854                         }
4855                 } else {
4856                         for _, k2 := range v2 {
4857                                 ee.EncodeFloat64(float64(k2))
4858                                 ee.EncodeUint(uint64(v[float64(k2)]))
4859                         }
4860                 }
4861         } else {
4862                 if esep {
4863                         for k2, v2 := range v {
4864                                 ee.WriteMapElemKey()
4865                                 ee.EncodeFloat64(k2)
4866                                 ee.WriteMapElemValue()
4867                                 ee.EncodeUint(uint64(v2))
4868                         }
4869                 } else {
4870                         for k2, v2 := range v {
4871                                 ee.EncodeFloat64(k2)
4872                                 ee.EncodeUint(uint64(v2))
4873                         }
4874                 }
4875         }
4876         ee.WriteMapEnd()
4877 }
4878
4879 func (e *Encoder) fastpathEncMapFloat64Uint8R(f *codecFnInfo, rv reflect.Value) {
4880         fastpathTV.EncMapFloat64Uint8V(rv2i(rv).(map[float64]uint8), e)
4881 }
4882 func (_ fastpathT) EncMapFloat64Uint8V(v map[float64]uint8, e *Encoder) {
4883         if v == nil {
4884                 e.e.EncodeNil()
4885                 return
4886         }
4887         ee, esep := e.e, e.hh.hasElemSeparators()
4888         ee.WriteMapStart(len(v))
4889         if e.h.Canonical {
4890                 v2 := make([]float64, len(v))
4891                 var i int
4892                 for k, _ := range v {
4893                         v2[i] = float64(k)
4894                         i++
4895                 }
4896                 sort.Sort(floatSlice(v2))
4897                 if esep {
4898                         for _, k2 := range v2 {
4899                                 ee.WriteMapElemKey()
4900                                 ee.EncodeFloat64(float64(k2))
4901                                 ee.WriteMapElemValue()
4902                                 ee.EncodeUint(uint64(v[float64(k2)]))
4903                         }
4904                 } else {
4905                         for _, k2 := range v2 {
4906                                 ee.EncodeFloat64(float64(k2))
4907                                 ee.EncodeUint(uint64(v[float64(k2)]))
4908                         }
4909                 }
4910         } else {
4911                 if esep {
4912                         for k2, v2 := range v {
4913                                 ee.WriteMapElemKey()
4914                                 ee.EncodeFloat64(k2)
4915                                 ee.WriteMapElemValue()
4916                                 ee.EncodeUint(uint64(v2))
4917                         }
4918                 } else {
4919                         for k2, v2 := range v {
4920                                 ee.EncodeFloat64(k2)
4921                                 ee.EncodeUint(uint64(v2))
4922                         }
4923                 }
4924         }
4925         ee.WriteMapEnd()
4926 }
4927
4928 func (e *Encoder) fastpathEncMapFloat64Uint16R(f *codecFnInfo, rv reflect.Value) {
4929         fastpathTV.EncMapFloat64Uint16V(rv2i(rv).(map[float64]uint16), e)
4930 }
4931 func (_ fastpathT) EncMapFloat64Uint16V(v map[float64]uint16, e *Encoder) {
4932         if v == nil {
4933                 e.e.EncodeNil()
4934                 return
4935         }
4936         ee, esep := e.e, e.hh.hasElemSeparators()
4937         ee.WriteMapStart(len(v))
4938         if e.h.Canonical {
4939                 v2 := make([]float64, len(v))
4940                 var i int
4941                 for k, _ := range v {
4942                         v2[i] = float64(k)
4943                         i++
4944                 }
4945                 sort.Sort(floatSlice(v2))
4946                 if esep {
4947                         for _, k2 := range v2 {
4948                                 ee.WriteMapElemKey()
4949                                 ee.EncodeFloat64(float64(k2))
4950                                 ee.WriteMapElemValue()
4951                                 ee.EncodeUint(uint64(v[float64(k2)]))
4952                         }
4953                 } else {
4954                         for _, k2 := range v2 {
4955                                 ee.EncodeFloat64(float64(k2))
4956                                 ee.EncodeUint(uint64(v[float64(k2)]))
4957                         }
4958                 }
4959         } else {
4960                 if esep {
4961                         for k2, v2 := range v {
4962                                 ee.WriteMapElemKey()
4963                                 ee.EncodeFloat64(k2)
4964                                 ee.WriteMapElemValue()
4965                                 ee.EncodeUint(uint64(v2))
4966                         }
4967                 } else {
4968                         for k2, v2 := range v {
4969                                 ee.EncodeFloat64(k2)
4970                                 ee.EncodeUint(uint64(v2))
4971                         }
4972                 }
4973         }
4974         ee.WriteMapEnd()
4975 }
4976
4977 func (e *Encoder) fastpathEncMapFloat64Uint32R(f *codecFnInfo, rv reflect.Value) {
4978         fastpathTV.EncMapFloat64Uint32V(rv2i(rv).(map[float64]uint32), e)
4979 }
4980 func (_ fastpathT) EncMapFloat64Uint32V(v map[float64]uint32, e *Encoder) {
4981         if v == nil {
4982                 e.e.EncodeNil()
4983                 return
4984         }
4985         ee, esep := e.e, e.hh.hasElemSeparators()
4986         ee.WriteMapStart(len(v))
4987         if e.h.Canonical {
4988                 v2 := make([]float64, len(v))
4989                 var i int
4990                 for k, _ := range v {
4991                         v2[i] = float64(k)
4992                         i++
4993                 }
4994                 sort.Sort(floatSlice(v2))
4995                 if esep {
4996                         for _, k2 := range v2 {
4997                                 ee.WriteMapElemKey()
4998                                 ee.EncodeFloat64(float64(k2))
4999                                 ee.WriteMapElemValue()
5000                                 ee.EncodeUint(uint64(v[float64(k2)]))
5001                         }
5002                 } else {
5003                         for _, k2 := range v2 {
5004                                 ee.EncodeFloat64(float64(k2))
5005                                 ee.EncodeUint(uint64(v[float64(k2)]))
5006                         }
5007                 }
5008         } else {
5009                 if esep {
5010                         for k2, v2 := range v {
5011                                 ee.WriteMapElemKey()
5012                                 ee.EncodeFloat64(k2)
5013                                 ee.WriteMapElemValue()
5014                                 ee.EncodeUint(uint64(v2))
5015                         }
5016                 } else {
5017                         for k2, v2 := range v {
5018                                 ee.EncodeFloat64(k2)
5019                                 ee.EncodeUint(uint64(v2))
5020                         }
5021                 }
5022         }
5023         ee.WriteMapEnd()
5024 }
5025
5026 func (e *Encoder) fastpathEncMapFloat64Uint64R(f *codecFnInfo, rv reflect.Value) {
5027         fastpathTV.EncMapFloat64Uint64V(rv2i(rv).(map[float64]uint64), e)
5028 }
5029 func (_ fastpathT) EncMapFloat64Uint64V(v map[float64]uint64, e *Encoder) {
5030         if v == nil {
5031                 e.e.EncodeNil()
5032                 return
5033         }
5034         ee, esep := e.e, e.hh.hasElemSeparators()
5035         ee.WriteMapStart(len(v))
5036         if e.h.Canonical {
5037                 v2 := make([]float64, len(v))
5038                 var i int
5039                 for k, _ := range v {
5040                         v2[i] = float64(k)
5041                         i++
5042                 }
5043                 sort.Sort(floatSlice(v2))
5044                 if esep {
5045                         for _, k2 := range v2 {
5046                                 ee.WriteMapElemKey()
5047                                 ee.EncodeFloat64(float64(k2))
5048                                 ee.WriteMapElemValue()
5049                                 ee.EncodeUint(uint64(v[float64(k2)]))
5050                         }
5051                 } else {
5052                         for _, k2 := range v2 {
5053                                 ee.EncodeFloat64(float64(k2))
5054                                 ee.EncodeUint(uint64(v[float64(k2)]))
5055                         }
5056                 }
5057         } else {
5058                 if esep {
5059                         for k2, v2 := range v {
5060                                 ee.WriteMapElemKey()
5061                                 ee.EncodeFloat64(k2)
5062                                 ee.WriteMapElemValue()
5063                                 ee.EncodeUint(uint64(v2))
5064                         }
5065                 } else {
5066                         for k2, v2 := range v {
5067                                 ee.EncodeFloat64(k2)
5068                                 ee.EncodeUint(uint64(v2))
5069                         }
5070                 }
5071         }
5072         ee.WriteMapEnd()
5073 }
5074
5075 func (e *Encoder) fastpathEncMapFloat64UintptrR(f *codecFnInfo, rv reflect.Value) {
5076         fastpathTV.EncMapFloat64UintptrV(rv2i(rv).(map[float64]uintptr), e)
5077 }
5078 func (_ fastpathT) EncMapFloat64UintptrV(v map[float64]uintptr, e *Encoder) {
5079         if v == nil {
5080                 e.e.EncodeNil()
5081                 return
5082         }
5083         ee, esep := e.e, e.hh.hasElemSeparators()
5084         ee.WriteMapStart(len(v))
5085         if e.h.Canonical {
5086                 v2 := make([]float64, len(v))
5087                 var i int
5088                 for k, _ := range v {
5089                         v2[i] = float64(k)
5090                         i++
5091                 }
5092                 sort.Sort(floatSlice(v2))
5093                 if esep {
5094                         for _, k2 := range v2 {
5095                                 ee.WriteMapElemKey()
5096                                 ee.EncodeFloat64(float64(k2))
5097                                 ee.WriteMapElemValue()
5098                                 e.encode(v[float64(k2)])
5099                         }
5100                 } else {
5101                         for _, k2 := range v2 {
5102                                 ee.EncodeFloat64(float64(k2))
5103                                 e.encode(v[float64(k2)])
5104                         }
5105                 }
5106         } else {
5107                 if esep {
5108                         for k2, v2 := range v {
5109                                 ee.WriteMapElemKey()
5110                                 ee.EncodeFloat64(k2)
5111                                 ee.WriteMapElemValue()
5112                                 e.encode(v2)
5113                         }
5114                 } else {
5115                         for k2, v2 := range v {
5116                                 ee.EncodeFloat64(k2)
5117                                 e.encode(v2)
5118                         }
5119                 }
5120         }
5121         ee.WriteMapEnd()
5122 }
5123
5124 func (e *Encoder) fastpathEncMapFloat64IntR(f *codecFnInfo, rv reflect.Value) {
5125         fastpathTV.EncMapFloat64IntV(rv2i(rv).(map[float64]int), e)
5126 }
5127 func (_ fastpathT) EncMapFloat64IntV(v map[float64]int, e *Encoder) {
5128         if v == nil {
5129                 e.e.EncodeNil()
5130                 return
5131         }
5132         ee, esep := e.e, e.hh.hasElemSeparators()
5133         ee.WriteMapStart(len(v))
5134         if e.h.Canonical {
5135                 v2 := make([]float64, len(v))
5136                 var i int
5137                 for k, _ := range v {
5138                         v2[i] = float64(k)
5139                         i++
5140                 }
5141                 sort.Sort(floatSlice(v2))
5142                 if esep {
5143                         for _, k2 := range v2 {
5144                                 ee.WriteMapElemKey()
5145                                 ee.EncodeFloat64(float64(k2))
5146                                 ee.WriteMapElemValue()
5147                                 ee.EncodeInt(int64(v[float64(k2)]))
5148                         }
5149                 } else {
5150                         for _, k2 := range v2 {
5151                                 ee.EncodeFloat64(float64(k2))
5152                                 ee.EncodeInt(int64(v[float64(k2)]))
5153                         }
5154                 }
5155         } else {
5156                 if esep {
5157                         for k2, v2 := range v {
5158                                 ee.WriteMapElemKey()
5159                                 ee.EncodeFloat64(k2)
5160                                 ee.WriteMapElemValue()
5161                                 ee.EncodeInt(int64(v2))
5162                         }
5163                 } else {
5164                         for k2, v2 := range v {
5165                                 ee.EncodeFloat64(k2)
5166                                 ee.EncodeInt(int64(v2))
5167                         }
5168                 }
5169         }
5170         ee.WriteMapEnd()
5171 }
5172
5173 func (e *Encoder) fastpathEncMapFloat64Int8R(f *codecFnInfo, rv reflect.Value) {
5174         fastpathTV.EncMapFloat64Int8V(rv2i(rv).(map[float64]int8), e)
5175 }
5176 func (_ fastpathT) EncMapFloat64Int8V(v map[float64]int8, e *Encoder) {
5177         if v == nil {
5178                 e.e.EncodeNil()
5179                 return
5180         }
5181         ee, esep := e.e, e.hh.hasElemSeparators()
5182         ee.WriteMapStart(len(v))
5183         if e.h.Canonical {
5184                 v2 := make([]float64, len(v))
5185                 var i int
5186                 for k, _ := range v {
5187                         v2[i] = float64(k)
5188                         i++
5189                 }
5190                 sort.Sort(floatSlice(v2))
5191                 if esep {
5192                         for _, k2 := range v2 {
5193                                 ee.WriteMapElemKey()
5194                                 ee.EncodeFloat64(float64(k2))
5195                                 ee.WriteMapElemValue()
5196                                 ee.EncodeInt(int64(v[float64(k2)]))
5197                         }
5198                 } else {
5199                         for _, k2 := range v2 {
5200                                 ee.EncodeFloat64(float64(k2))
5201                                 ee.EncodeInt(int64(v[float64(k2)]))
5202                         }
5203                 }
5204         } else {
5205                 if esep {
5206                         for k2, v2 := range v {
5207                                 ee.WriteMapElemKey()
5208                                 ee.EncodeFloat64(k2)
5209                                 ee.WriteMapElemValue()
5210                                 ee.EncodeInt(int64(v2))
5211                         }
5212                 } else {
5213                         for k2, v2 := range v {
5214                                 ee.EncodeFloat64(k2)
5215                                 ee.EncodeInt(int64(v2))
5216                         }
5217                 }
5218         }
5219         ee.WriteMapEnd()
5220 }
5221
5222 func (e *Encoder) fastpathEncMapFloat64Int16R(f *codecFnInfo, rv reflect.Value) {
5223         fastpathTV.EncMapFloat64Int16V(rv2i(rv).(map[float64]int16), e)
5224 }
5225 func (_ fastpathT) EncMapFloat64Int16V(v map[float64]int16, e *Encoder) {
5226         if v == nil {
5227                 e.e.EncodeNil()
5228                 return
5229         }
5230         ee, esep := e.e, e.hh.hasElemSeparators()
5231         ee.WriteMapStart(len(v))
5232         if e.h.Canonical {
5233                 v2 := make([]float64, len(v))
5234                 var i int
5235                 for k, _ := range v {
5236                         v2[i] = float64(k)
5237                         i++
5238                 }
5239                 sort.Sort(floatSlice(v2))
5240                 if esep {
5241                         for _, k2 := range v2 {
5242                                 ee.WriteMapElemKey()
5243                                 ee.EncodeFloat64(float64(k2))
5244                                 ee.WriteMapElemValue()
5245                                 ee.EncodeInt(int64(v[float64(k2)]))
5246                         }
5247                 } else {
5248                         for _, k2 := range v2 {
5249                                 ee.EncodeFloat64(float64(k2))
5250                                 ee.EncodeInt(int64(v[float64(k2)]))
5251                         }
5252                 }
5253         } else {
5254                 if esep {
5255                         for k2, v2 := range v {
5256                                 ee.WriteMapElemKey()
5257                                 ee.EncodeFloat64(k2)
5258                                 ee.WriteMapElemValue()
5259                                 ee.EncodeInt(int64(v2))
5260                         }
5261                 } else {
5262                         for k2, v2 := range v {
5263                                 ee.EncodeFloat64(k2)
5264                                 ee.EncodeInt(int64(v2))
5265                         }
5266                 }
5267         }
5268         ee.WriteMapEnd()
5269 }
5270
5271 func (e *Encoder) fastpathEncMapFloat64Int32R(f *codecFnInfo, rv reflect.Value) {
5272         fastpathTV.EncMapFloat64Int32V(rv2i(rv).(map[float64]int32), e)
5273 }
5274 func (_ fastpathT) EncMapFloat64Int32V(v map[float64]int32, e *Encoder) {
5275         if v == nil {
5276                 e.e.EncodeNil()
5277                 return
5278         }
5279         ee, esep := e.e, e.hh.hasElemSeparators()
5280         ee.WriteMapStart(len(v))
5281         if e.h.Canonical {
5282                 v2 := make([]float64, len(v))
5283                 var i int
5284                 for k, _ := range v {
5285                         v2[i] = float64(k)
5286                         i++
5287                 }
5288                 sort.Sort(floatSlice(v2))
5289                 if esep {
5290                         for _, k2 := range v2 {
5291                                 ee.WriteMapElemKey()
5292                                 ee.EncodeFloat64(float64(k2))
5293                                 ee.WriteMapElemValue()
5294                                 ee.EncodeInt(int64(v[float64(k2)]))
5295                         }
5296                 } else {
5297                         for _, k2 := range v2 {
5298                                 ee.EncodeFloat64(float64(k2))
5299                                 ee.EncodeInt(int64(v[float64(k2)]))
5300                         }
5301                 }
5302         } else {
5303                 if esep {
5304                         for k2, v2 := range v {
5305                                 ee.WriteMapElemKey()
5306                                 ee.EncodeFloat64(k2)
5307                                 ee.WriteMapElemValue()
5308                                 ee.EncodeInt(int64(v2))
5309                         }
5310                 } else {
5311                         for k2, v2 := range v {
5312                                 ee.EncodeFloat64(k2)
5313                                 ee.EncodeInt(int64(v2))
5314                         }
5315                 }
5316         }
5317         ee.WriteMapEnd()
5318 }
5319
5320 func (e *Encoder) fastpathEncMapFloat64Int64R(f *codecFnInfo, rv reflect.Value) {
5321         fastpathTV.EncMapFloat64Int64V(rv2i(rv).(map[float64]int64), e)
5322 }
5323 func (_ fastpathT) EncMapFloat64Int64V(v map[float64]int64, e *Encoder) {
5324         if v == nil {
5325                 e.e.EncodeNil()
5326                 return
5327         }
5328         ee, esep := e.e, e.hh.hasElemSeparators()
5329         ee.WriteMapStart(len(v))
5330         if e.h.Canonical {
5331                 v2 := make([]float64, len(v))
5332                 var i int
5333                 for k, _ := range v {
5334                         v2[i] = float64(k)
5335                         i++
5336                 }
5337                 sort.Sort(floatSlice(v2))
5338                 if esep {
5339                         for _, k2 := range v2 {
5340                                 ee.WriteMapElemKey()
5341                                 ee.EncodeFloat64(float64(k2))
5342                                 ee.WriteMapElemValue()
5343                                 ee.EncodeInt(int64(v[float64(k2)]))
5344                         }
5345                 } else {
5346                         for _, k2 := range v2 {
5347                                 ee.EncodeFloat64(float64(k2))
5348                                 ee.EncodeInt(int64(v[float64(k2)]))
5349                         }
5350                 }
5351         } else {
5352                 if esep {
5353                         for k2, v2 := range v {
5354                                 ee.WriteMapElemKey()
5355                                 ee.EncodeFloat64(k2)
5356                                 ee.WriteMapElemValue()
5357                                 ee.EncodeInt(int64(v2))
5358                         }
5359                 } else {
5360                         for k2, v2 := range v {
5361                                 ee.EncodeFloat64(k2)
5362                                 ee.EncodeInt(int64(v2))
5363                         }
5364                 }
5365         }
5366         ee.WriteMapEnd()
5367 }
5368
5369 func (e *Encoder) fastpathEncMapFloat64Float32R(f *codecFnInfo, rv reflect.Value) {
5370         fastpathTV.EncMapFloat64Float32V(rv2i(rv).(map[float64]float32), e)
5371 }
5372 func (_ fastpathT) EncMapFloat64Float32V(v map[float64]float32, e *Encoder) {
5373         if v == nil {
5374                 e.e.EncodeNil()
5375                 return
5376         }
5377         ee, esep := e.e, e.hh.hasElemSeparators()
5378         ee.WriteMapStart(len(v))
5379         if e.h.Canonical {
5380                 v2 := make([]float64, len(v))
5381                 var i int
5382                 for k, _ := range v {
5383                         v2[i] = float64(k)
5384                         i++
5385                 }
5386                 sort.Sort(floatSlice(v2))
5387                 if esep {
5388                         for _, k2 := range v2 {
5389                                 ee.WriteMapElemKey()
5390                                 ee.EncodeFloat64(float64(k2))
5391                                 ee.WriteMapElemValue()
5392                                 ee.EncodeFloat32(v[float64(k2)])
5393                         }
5394                 } else {
5395                         for _, k2 := range v2 {
5396                                 ee.EncodeFloat64(float64(k2))
5397                                 ee.EncodeFloat32(v[float64(k2)])
5398                         }
5399                 }
5400         } else {
5401                 if esep {
5402                         for k2, v2 := range v {
5403                                 ee.WriteMapElemKey()
5404                                 ee.EncodeFloat64(k2)
5405                                 ee.WriteMapElemValue()
5406                                 ee.EncodeFloat32(v2)
5407                         }
5408                 } else {
5409                         for k2, v2 := range v {
5410                                 ee.EncodeFloat64(k2)
5411                                 ee.EncodeFloat32(v2)
5412                         }
5413                 }
5414         }
5415         ee.WriteMapEnd()
5416 }
5417
5418 func (e *Encoder) fastpathEncMapFloat64Float64R(f *codecFnInfo, rv reflect.Value) {
5419         fastpathTV.EncMapFloat64Float64V(rv2i(rv).(map[float64]float64), e)
5420 }
5421 func (_ fastpathT) EncMapFloat64Float64V(v map[float64]float64, e *Encoder) {
5422         if v == nil {
5423                 e.e.EncodeNil()
5424                 return
5425         }
5426         ee, esep := e.e, e.hh.hasElemSeparators()
5427         ee.WriteMapStart(len(v))
5428         if e.h.Canonical {
5429                 v2 := make([]float64, len(v))
5430                 var i int
5431                 for k, _ := range v {
5432                         v2[i] = float64(k)
5433                         i++
5434                 }
5435                 sort.Sort(floatSlice(v2))
5436                 if esep {
5437                         for _, k2 := range v2 {
5438                                 ee.WriteMapElemKey()
5439                                 ee.EncodeFloat64(float64(k2))
5440                                 ee.WriteMapElemValue()
5441                                 ee.EncodeFloat64(v[float64(k2)])
5442                         }
5443                 } else {
5444                         for _, k2 := range v2 {
5445                                 ee.EncodeFloat64(float64(k2))
5446                                 ee.EncodeFloat64(v[float64(k2)])
5447                         }
5448                 }
5449         } else {
5450                 if esep {
5451                         for k2, v2 := range v {
5452                                 ee.WriteMapElemKey()
5453                                 ee.EncodeFloat64(k2)
5454                                 ee.WriteMapElemValue()
5455                                 ee.EncodeFloat64(v2)
5456                         }
5457                 } else {
5458                         for k2, v2 := range v {
5459                                 ee.EncodeFloat64(k2)
5460                                 ee.EncodeFloat64(v2)
5461                         }
5462                 }
5463         }
5464         ee.WriteMapEnd()
5465 }
5466
5467 func (e *Encoder) fastpathEncMapFloat64BoolR(f *codecFnInfo, rv reflect.Value) {
5468         fastpathTV.EncMapFloat64BoolV(rv2i(rv).(map[float64]bool), e)
5469 }
5470 func (_ fastpathT) EncMapFloat64BoolV(v map[float64]bool, e *Encoder) {
5471         if v == nil {
5472                 e.e.EncodeNil()
5473                 return
5474         }
5475         ee, esep := e.e, e.hh.hasElemSeparators()
5476         ee.WriteMapStart(len(v))
5477         if e.h.Canonical {
5478                 v2 := make([]float64, len(v))
5479                 var i int
5480                 for k, _ := range v {
5481                         v2[i] = float64(k)
5482                         i++
5483                 }
5484                 sort.Sort(floatSlice(v2))
5485                 if esep {
5486                         for _, k2 := range v2 {
5487                                 ee.WriteMapElemKey()
5488                                 ee.EncodeFloat64(float64(k2))
5489                                 ee.WriteMapElemValue()
5490                                 ee.EncodeBool(v[float64(k2)])
5491                         }
5492                 } else {
5493                         for _, k2 := range v2 {
5494                                 ee.EncodeFloat64(float64(k2))
5495                                 ee.EncodeBool(v[float64(k2)])
5496                         }
5497                 }
5498         } else {
5499                 if esep {
5500                         for k2, v2 := range v {
5501                                 ee.WriteMapElemKey()
5502                                 ee.EncodeFloat64(k2)
5503                                 ee.WriteMapElemValue()
5504                                 ee.EncodeBool(v2)
5505                         }
5506                 } else {
5507                         for k2, v2 := range v {
5508                                 ee.EncodeFloat64(k2)
5509                                 ee.EncodeBool(v2)
5510                         }
5511                 }
5512         }
5513         ee.WriteMapEnd()
5514 }
5515
5516 func (e *Encoder) fastpathEncMapUintIntfR(f *codecFnInfo, rv reflect.Value) {
5517         fastpathTV.EncMapUintIntfV(rv2i(rv).(map[uint]interface{}), e)
5518 }
5519 func (_ fastpathT) EncMapUintIntfV(v map[uint]interface{}, e *Encoder) {
5520         if v == nil {
5521                 e.e.EncodeNil()
5522                 return
5523         }
5524         ee, esep := e.e, e.hh.hasElemSeparators()
5525         ee.WriteMapStart(len(v))
5526         if e.h.Canonical {
5527                 v2 := make([]uint64, len(v))
5528                 var i int
5529                 for k, _ := range v {
5530                         v2[i] = uint64(k)
5531                         i++
5532                 }
5533                 sort.Sort(uintSlice(v2))
5534                 if esep {
5535                         for _, k2 := range v2 {
5536                                 ee.WriteMapElemKey()
5537                                 ee.EncodeUint(uint64(uint(k2)))
5538                                 ee.WriteMapElemValue()
5539                                 e.encode(v[uint(k2)])
5540                         }
5541                 } else {
5542                         for _, k2 := range v2 {
5543                                 ee.EncodeUint(uint64(uint(k2)))
5544                                 e.encode(v[uint(k2)])
5545                         }
5546                 }
5547         } else {
5548                 if esep {
5549                         for k2, v2 := range v {
5550                                 ee.WriteMapElemKey()
5551                                 ee.EncodeUint(uint64(k2))
5552                                 ee.WriteMapElemValue()
5553                                 e.encode(v2)
5554                         }
5555                 } else {
5556                         for k2, v2 := range v {
5557                                 ee.EncodeUint(uint64(k2))
5558                                 e.encode(v2)
5559                         }
5560                 }
5561         }
5562         ee.WriteMapEnd()
5563 }
5564
5565 func (e *Encoder) fastpathEncMapUintStringR(f *codecFnInfo, rv reflect.Value) {
5566         fastpathTV.EncMapUintStringV(rv2i(rv).(map[uint]string), e)
5567 }
5568 func (_ fastpathT) EncMapUintStringV(v map[uint]string, e *Encoder) {
5569         if v == nil {
5570                 e.e.EncodeNil()
5571                 return
5572         }
5573         ee, esep := e.e, e.hh.hasElemSeparators()
5574         ee.WriteMapStart(len(v))
5575         if e.h.Canonical {
5576                 v2 := make([]uint64, len(v))
5577                 var i int
5578                 for k, _ := range v {
5579                         v2[i] = uint64(k)
5580                         i++
5581                 }
5582                 sort.Sort(uintSlice(v2))
5583                 if esep {
5584                         for _, k2 := range v2 {
5585                                 ee.WriteMapElemKey()
5586                                 ee.EncodeUint(uint64(uint(k2)))
5587                                 ee.WriteMapElemValue()
5588                                 ee.EncodeString(cUTF8, v[uint(k2)])
5589                         }
5590                 } else {
5591                         for _, k2 := range v2 {
5592                                 ee.EncodeUint(uint64(uint(k2)))
5593                                 ee.EncodeString(cUTF8, v[uint(k2)])
5594                         }
5595                 }
5596         } else {
5597                 if esep {
5598                         for k2, v2 := range v {
5599                                 ee.WriteMapElemKey()
5600                                 ee.EncodeUint(uint64(k2))
5601                                 ee.WriteMapElemValue()
5602                                 ee.EncodeString(cUTF8, v2)
5603                         }
5604                 } else {
5605                         for k2, v2 := range v {
5606                                 ee.EncodeUint(uint64(k2))
5607                                 ee.EncodeString(cUTF8, v2)
5608                         }
5609                 }
5610         }
5611         ee.WriteMapEnd()
5612 }
5613
5614 func (e *Encoder) fastpathEncMapUintUintR(f *codecFnInfo, rv reflect.Value) {
5615         fastpathTV.EncMapUintUintV(rv2i(rv).(map[uint]uint), e)
5616 }
5617 func (_ fastpathT) EncMapUintUintV(v map[uint]uint, e *Encoder) {
5618         if v == nil {
5619                 e.e.EncodeNil()
5620                 return
5621         }
5622         ee, esep := e.e, e.hh.hasElemSeparators()
5623         ee.WriteMapStart(len(v))
5624         if e.h.Canonical {
5625                 v2 := make([]uint64, len(v))
5626                 var i int
5627                 for k, _ := range v {
5628                         v2[i] = uint64(k)
5629                         i++
5630                 }
5631                 sort.Sort(uintSlice(v2))
5632                 if esep {
5633                         for _, k2 := range v2 {
5634                                 ee.WriteMapElemKey()
5635                                 ee.EncodeUint(uint64(uint(k2)))
5636                                 ee.WriteMapElemValue()
5637                                 ee.EncodeUint(uint64(v[uint(k2)]))
5638                         }
5639                 } else {
5640                         for _, k2 := range v2 {
5641                                 ee.EncodeUint(uint64(uint(k2)))
5642                                 ee.EncodeUint(uint64(v[uint(k2)]))
5643                         }
5644                 }
5645         } else {
5646                 if esep {
5647                         for k2, v2 := range v {
5648                                 ee.WriteMapElemKey()
5649                                 ee.EncodeUint(uint64(k2))
5650                                 ee.WriteMapElemValue()
5651                                 ee.EncodeUint(uint64(v2))
5652                         }
5653                 } else {
5654                         for k2, v2 := range v {
5655                                 ee.EncodeUint(uint64(k2))
5656                                 ee.EncodeUint(uint64(v2))
5657                         }
5658                 }
5659         }
5660         ee.WriteMapEnd()
5661 }
5662
5663 func (e *Encoder) fastpathEncMapUintUint8R(f *codecFnInfo, rv reflect.Value) {
5664         fastpathTV.EncMapUintUint8V(rv2i(rv).(map[uint]uint8), e)
5665 }
5666 func (_ fastpathT) EncMapUintUint8V(v map[uint]uint8, e *Encoder) {
5667         if v == nil {
5668                 e.e.EncodeNil()
5669                 return
5670         }
5671         ee, esep := e.e, e.hh.hasElemSeparators()
5672         ee.WriteMapStart(len(v))
5673         if e.h.Canonical {
5674                 v2 := make([]uint64, len(v))
5675                 var i int
5676                 for k, _ := range v {
5677                         v2[i] = uint64(k)
5678                         i++
5679                 }
5680                 sort.Sort(uintSlice(v2))
5681                 if esep {
5682                         for _, k2 := range v2 {
5683                                 ee.WriteMapElemKey()
5684                                 ee.EncodeUint(uint64(uint(k2)))
5685                                 ee.WriteMapElemValue()
5686                                 ee.EncodeUint(uint64(v[uint(k2)]))
5687                         }
5688                 } else {
5689                         for _, k2 := range v2 {
5690                                 ee.EncodeUint(uint64(uint(k2)))
5691                                 ee.EncodeUint(uint64(v[uint(k2)]))
5692                         }
5693                 }
5694         } else {
5695                 if esep {
5696                         for k2, v2 := range v {
5697                                 ee.WriteMapElemKey()
5698                                 ee.EncodeUint(uint64(k2))
5699                                 ee.WriteMapElemValue()
5700                                 ee.EncodeUint(uint64(v2))
5701                         }
5702                 } else {
5703                         for k2, v2 := range v {
5704                                 ee.EncodeUint(uint64(k2))
5705                                 ee.EncodeUint(uint64(v2))
5706                         }
5707                 }
5708         }
5709         ee.WriteMapEnd()
5710 }
5711
5712 func (e *Encoder) fastpathEncMapUintUint16R(f *codecFnInfo, rv reflect.Value) {
5713         fastpathTV.EncMapUintUint16V(rv2i(rv).(map[uint]uint16), e)
5714 }
5715 func (_ fastpathT) EncMapUintUint16V(v map[uint]uint16, e *Encoder) {
5716         if v == nil {
5717                 e.e.EncodeNil()
5718                 return
5719         }
5720         ee, esep := e.e, e.hh.hasElemSeparators()
5721         ee.WriteMapStart(len(v))
5722         if e.h.Canonical {
5723                 v2 := make([]uint64, len(v))
5724                 var i int
5725                 for k, _ := range v {
5726                         v2[i] = uint64(k)
5727                         i++
5728                 }
5729                 sort.Sort(uintSlice(v2))
5730                 if esep {
5731                         for _, k2 := range v2 {
5732                                 ee.WriteMapElemKey()
5733                                 ee.EncodeUint(uint64(uint(k2)))
5734                                 ee.WriteMapElemValue()
5735                                 ee.EncodeUint(uint64(v[uint(k2)]))
5736                         }
5737                 } else {
5738                         for _, k2 := range v2 {
5739                                 ee.EncodeUint(uint64(uint(k2)))
5740                                 ee.EncodeUint(uint64(v[uint(k2)]))
5741                         }
5742                 }
5743         } else {
5744                 if esep {
5745                         for k2, v2 := range v {
5746                                 ee.WriteMapElemKey()
5747                                 ee.EncodeUint(uint64(k2))
5748                                 ee.WriteMapElemValue()
5749                                 ee.EncodeUint(uint64(v2))
5750                         }
5751                 } else {
5752                         for k2, v2 := range v {
5753                                 ee.EncodeUint(uint64(k2))
5754                                 ee.EncodeUint(uint64(v2))
5755                         }
5756                 }
5757         }
5758         ee.WriteMapEnd()
5759 }
5760
5761 func (e *Encoder) fastpathEncMapUintUint32R(f *codecFnInfo, rv reflect.Value) {
5762         fastpathTV.EncMapUintUint32V(rv2i(rv).(map[uint]uint32), e)
5763 }
5764 func (_ fastpathT) EncMapUintUint32V(v map[uint]uint32, e *Encoder) {
5765         if v == nil {
5766                 e.e.EncodeNil()
5767                 return
5768         }
5769         ee, esep := e.e, e.hh.hasElemSeparators()
5770         ee.WriteMapStart(len(v))
5771         if e.h.Canonical {
5772                 v2 := make([]uint64, len(v))
5773                 var i int
5774                 for k, _ := range v {
5775                         v2[i] = uint64(k)
5776                         i++
5777                 }
5778                 sort.Sort(uintSlice(v2))
5779                 if esep {
5780                         for _, k2 := range v2 {
5781                                 ee.WriteMapElemKey()
5782                                 ee.EncodeUint(uint64(uint(k2)))
5783                                 ee.WriteMapElemValue()
5784                                 ee.EncodeUint(uint64(v[uint(k2)]))
5785                         }
5786                 } else {
5787                         for _, k2 := range v2 {
5788                                 ee.EncodeUint(uint64(uint(k2)))
5789                                 ee.EncodeUint(uint64(v[uint(k2)]))
5790                         }
5791                 }
5792         } else {
5793                 if esep {
5794                         for k2, v2 := range v {
5795                                 ee.WriteMapElemKey()
5796                                 ee.EncodeUint(uint64(k2))
5797                                 ee.WriteMapElemValue()
5798                                 ee.EncodeUint(uint64(v2))
5799                         }
5800                 } else {
5801                         for k2, v2 := range v {
5802                                 ee.EncodeUint(uint64(k2))
5803                                 ee.EncodeUint(uint64(v2))
5804                         }
5805                 }
5806         }
5807         ee.WriteMapEnd()
5808 }
5809
5810 func (e *Encoder) fastpathEncMapUintUint64R(f *codecFnInfo, rv reflect.Value) {
5811         fastpathTV.EncMapUintUint64V(rv2i(rv).(map[uint]uint64), e)
5812 }
5813 func (_ fastpathT) EncMapUintUint64V(v map[uint]uint64, e *Encoder) {
5814         if v == nil {
5815                 e.e.EncodeNil()
5816                 return
5817         }
5818         ee, esep := e.e, e.hh.hasElemSeparators()
5819         ee.WriteMapStart(len(v))
5820         if e.h.Canonical {
5821                 v2 := make([]uint64, len(v))
5822                 var i int
5823                 for k, _ := range v {
5824                         v2[i] = uint64(k)
5825                         i++
5826                 }
5827                 sort.Sort(uintSlice(v2))
5828                 if esep {
5829                         for _, k2 := range v2 {
5830                                 ee.WriteMapElemKey()
5831                                 ee.EncodeUint(uint64(uint(k2)))
5832                                 ee.WriteMapElemValue()
5833                                 ee.EncodeUint(uint64(v[uint(k2)]))
5834                         }
5835                 } else {
5836                         for _, k2 := range v2 {
5837                                 ee.EncodeUint(uint64(uint(k2)))
5838                                 ee.EncodeUint(uint64(v[uint(k2)]))
5839                         }
5840                 }
5841         } else {
5842                 if esep {
5843                         for k2, v2 := range v {
5844                                 ee.WriteMapElemKey()
5845                                 ee.EncodeUint(uint64(k2))
5846                                 ee.WriteMapElemValue()
5847                                 ee.EncodeUint(uint64(v2))
5848                         }
5849                 } else {
5850                         for k2, v2 := range v {
5851                                 ee.EncodeUint(uint64(k2))
5852                                 ee.EncodeUint(uint64(v2))
5853                         }
5854                 }
5855         }
5856         ee.WriteMapEnd()
5857 }
5858
5859 func (e *Encoder) fastpathEncMapUintUintptrR(f *codecFnInfo, rv reflect.Value) {
5860         fastpathTV.EncMapUintUintptrV(rv2i(rv).(map[uint]uintptr), e)
5861 }
5862 func (_ fastpathT) EncMapUintUintptrV(v map[uint]uintptr, e *Encoder) {
5863         if v == nil {
5864                 e.e.EncodeNil()
5865                 return
5866         }
5867         ee, esep := e.e, e.hh.hasElemSeparators()
5868         ee.WriteMapStart(len(v))
5869         if e.h.Canonical {
5870                 v2 := make([]uint64, len(v))
5871                 var i int
5872                 for k, _ := range v {
5873                         v2[i] = uint64(k)
5874                         i++
5875                 }
5876                 sort.Sort(uintSlice(v2))
5877                 if esep {
5878                         for _, k2 := range v2 {
5879                                 ee.WriteMapElemKey()
5880                                 ee.EncodeUint(uint64(uint(k2)))
5881                                 ee.WriteMapElemValue()
5882                                 e.encode(v[uint(k2)])
5883                         }
5884                 } else {
5885                         for _, k2 := range v2 {
5886                                 ee.EncodeUint(uint64(uint(k2)))
5887                                 e.encode(v[uint(k2)])
5888                         }
5889                 }
5890         } else {
5891                 if esep {
5892                         for k2, v2 := range v {
5893                                 ee.WriteMapElemKey()
5894                                 ee.EncodeUint(uint64(k2))
5895                                 ee.WriteMapElemValue()
5896                                 e.encode(v2)
5897                         }
5898                 } else {
5899                         for k2, v2 := range v {
5900                                 ee.EncodeUint(uint64(k2))
5901                                 e.encode(v2)
5902                         }
5903                 }
5904         }
5905         ee.WriteMapEnd()
5906 }
5907
5908 func (e *Encoder) fastpathEncMapUintIntR(f *codecFnInfo, rv reflect.Value) {
5909         fastpathTV.EncMapUintIntV(rv2i(rv).(map[uint]int), e)
5910 }
5911 func (_ fastpathT) EncMapUintIntV(v map[uint]int, e *Encoder) {
5912         if v == nil {
5913                 e.e.EncodeNil()
5914                 return
5915         }
5916         ee, esep := e.e, e.hh.hasElemSeparators()
5917         ee.WriteMapStart(len(v))
5918         if e.h.Canonical {
5919                 v2 := make([]uint64, len(v))
5920                 var i int
5921                 for k, _ := range v {
5922                         v2[i] = uint64(k)
5923                         i++
5924                 }
5925                 sort.Sort(uintSlice(v2))
5926                 if esep {
5927                         for _, k2 := range v2 {
5928                                 ee.WriteMapElemKey()
5929                                 ee.EncodeUint(uint64(uint(k2)))
5930                                 ee.WriteMapElemValue()
5931                                 ee.EncodeInt(int64(v[uint(k2)]))
5932                         }
5933                 } else {
5934                         for _, k2 := range v2 {
5935                                 ee.EncodeUint(uint64(uint(k2)))
5936                                 ee.EncodeInt(int64(v[uint(k2)]))
5937                         }
5938                 }
5939         } else {
5940                 if esep {
5941                         for k2, v2 := range v {
5942                                 ee.WriteMapElemKey()
5943                                 ee.EncodeUint(uint64(k2))
5944                                 ee.WriteMapElemValue()
5945                                 ee.EncodeInt(int64(v2))
5946                         }
5947                 } else {
5948                         for k2, v2 := range v {
5949                                 ee.EncodeUint(uint64(k2))
5950                                 ee.EncodeInt(int64(v2))
5951                         }
5952                 }
5953         }
5954         ee.WriteMapEnd()
5955 }
5956
5957 func (e *Encoder) fastpathEncMapUintInt8R(f *codecFnInfo, rv reflect.Value) {
5958         fastpathTV.EncMapUintInt8V(rv2i(rv).(map[uint]int8), e)
5959 }
5960 func (_ fastpathT) EncMapUintInt8V(v map[uint]int8, e *Encoder) {
5961         if v == nil {
5962                 e.e.EncodeNil()
5963                 return
5964         }
5965         ee, esep := e.e, e.hh.hasElemSeparators()
5966         ee.WriteMapStart(len(v))
5967         if e.h.Canonical {
5968                 v2 := make([]uint64, len(v))
5969                 var i int
5970                 for k, _ := range v {
5971                         v2[i] = uint64(k)
5972                         i++
5973                 }
5974                 sort.Sort(uintSlice(v2))
5975                 if esep {
5976                         for _, k2 := range v2 {
5977                                 ee.WriteMapElemKey()
5978                                 ee.EncodeUint(uint64(uint(k2)))
5979                                 ee.WriteMapElemValue()
5980                                 ee.EncodeInt(int64(v[uint(k2)]))
5981                         }
5982                 } else {
5983                         for _, k2 := range v2 {
5984                                 ee.EncodeUint(uint64(uint(k2)))
5985                                 ee.EncodeInt(int64(v[uint(k2)]))
5986                         }
5987                 }
5988         } else {
5989                 if esep {
5990                         for k2, v2 := range v {
5991                                 ee.WriteMapElemKey()
5992                                 ee.EncodeUint(uint64(k2))
5993                                 ee.WriteMapElemValue()
5994                                 ee.EncodeInt(int64(v2))
5995                         }
5996                 } else {
5997                         for k2, v2 := range v {
5998                                 ee.EncodeUint(uint64(k2))
5999                                 ee.EncodeInt(int64(v2))
6000                         }
6001                 }
6002         }
6003         ee.WriteMapEnd()
6004 }
6005
6006 func (e *Encoder) fastpathEncMapUintInt16R(f *codecFnInfo, rv reflect.Value) {
6007         fastpathTV.EncMapUintInt16V(rv2i(rv).(map[uint]int16), e)
6008 }
6009 func (_ fastpathT) EncMapUintInt16V(v map[uint]int16, e *Encoder) {
6010         if v == nil {
6011                 e.e.EncodeNil()
6012                 return
6013         }
6014         ee, esep := e.e, e.hh.hasElemSeparators()
6015         ee.WriteMapStart(len(v))
6016         if e.h.Canonical {
6017                 v2 := make([]uint64, len(v))
6018                 var i int
6019                 for k, _ := range v {
6020                         v2[i] = uint64(k)
6021                         i++
6022                 }
6023                 sort.Sort(uintSlice(v2))
6024                 if esep {
6025                         for _, k2 := range v2 {
6026                                 ee.WriteMapElemKey()
6027                                 ee.EncodeUint(uint64(uint(k2)))
6028                                 ee.WriteMapElemValue()
6029                                 ee.EncodeInt(int64(v[uint(k2)]))
6030                         }
6031                 } else {
6032                         for _, k2 := range v2 {
6033                                 ee.EncodeUint(uint64(uint(k2)))
6034                                 ee.EncodeInt(int64(v[uint(k2)]))
6035                         }
6036                 }
6037         } else {
6038                 if esep {
6039                         for k2, v2 := range v {
6040                                 ee.WriteMapElemKey()
6041                                 ee.EncodeUint(uint64(k2))
6042                                 ee.WriteMapElemValue()
6043                                 ee.EncodeInt(int64(v2))
6044                         }
6045                 } else {
6046                         for k2, v2 := range v {
6047                                 ee.EncodeUint(uint64(k2))
6048                                 ee.EncodeInt(int64(v2))
6049                         }
6050                 }
6051         }
6052         ee.WriteMapEnd()
6053 }
6054
6055 func (e *Encoder) fastpathEncMapUintInt32R(f *codecFnInfo, rv reflect.Value) {
6056         fastpathTV.EncMapUintInt32V(rv2i(rv).(map[uint]int32), e)
6057 }
6058 func (_ fastpathT) EncMapUintInt32V(v map[uint]int32, e *Encoder) {
6059         if v == nil {
6060                 e.e.EncodeNil()
6061                 return
6062         }
6063         ee, esep := e.e, e.hh.hasElemSeparators()
6064         ee.WriteMapStart(len(v))
6065         if e.h.Canonical {
6066                 v2 := make([]uint64, len(v))
6067                 var i int
6068                 for k, _ := range v {
6069                         v2[i] = uint64(k)
6070                         i++
6071                 }
6072                 sort.Sort(uintSlice(v2))
6073                 if esep {
6074                         for _, k2 := range v2 {
6075                                 ee.WriteMapElemKey()
6076                                 ee.EncodeUint(uint64(uint(k2)))
6077                                 ee.WriteMapElemValue()
6078                                 ee.EncodeInt(int64(v[uint(k2)]))
6079                         }
6080                 } else {
6081                         for _, k2 := range v2 {
6082                                 ee.EncodeUint(uint64(uint(k2)))
6083                                 ee.EncodeInt(int64(v[uint(k2)]))
6084                         }
6085                 }
6086         } else {
6087                 if esep {
6088                         for k2, v2 := range v {
6089                                 ee.WriteMapElemKey()
6090                                 ee.EncodeUint(uint64(k2))
6091                                 ee.WriteMapElemValue()
6092                                 ee.EncodeInt(int64(v2))
6093                         }
6094                 } else {
6095                         for k2, v2 := range v {
6096                                 ee.EncodeUint(uint64(k2))
6097                                 ee.EncodeInt(int64(v2))
6098                         }
6099                 }
6100         }
6101         ee.WriteMapEnd()
6102 }
6103
6104 func (e *Encoder) fastpathEncMapUintInt64R(f *codecFnInfo, rv reflect.Value) {
6105         fastpathTV.EncMapUintInt64V(rv2i(rv).(map[uint]int64), e)
6106 }
6107 func (_ fastpathT) EncMapUintInt64V(v map[uint]int64, e *Encoder) {
6108         if v == nil {
6109                 e.e.EncodeNil()
6110                 return
6111         }
6112         ee, esep := e.e, e.hh.hasElemSeparators()
6113         ee.WriteMapStart(len(v))
6114         if e.h.Canonical {
6115                 v2 := make([]uint64, len(v))
6116                 var i int
6117                 for k, _ := range v {
6118                         v2[i] = uint64(k)
6119                         i++
6120                 }
6121                 sort.Sort(uintSlice(v2))
6122                 if esep {
6123                         for _, k2 := range v2 {
6124                                 ee.WriteMapElemKey()
6125                                 ee.EncodeUint(uint64(uint(k2)))
6126                                 ee.WriteMapElemValue()
6127                                 ee.EncodeInt(int64(v[uint(k2)]))
6128                         }
6129                 } else {
6130                         for _, k2 := range v2 {
6131                                 ee.EncodeUint(uint64(uint(k2)))
6132                                 ee.EncodeInt(int64(v[uint(k2)]))
6133                         }
6134                 }
6135         } else {
6136                 if esep {
6137                         for k2, v2 := range v {
6138                                 ee.WriteMapElemKey()
6139                                 ee.EncodeUint(uint64(k2))
6140                                 ee.WriteMapElemValue()
6141                                 ee.EncodeInt(int64(v2))
6142                         }
6143                 } else {
6144                         for k2, v2 := range v {
6145                                 ee.EncodeUint(uint64(k2))
6146                                 ee.EncodeInt(int64(v2))
6147                         }
6148                 }
6149         }
6150         ee.WriteMapEnd()
6151 }
6152
6153 func (e *Encoder) fastpathEncMapUintFloat32R(f *codecFnInfo, rv reflect.Value) {
6154         fastpathTV.EncMapUintFloat32V(rv2i(rv).(map[uint]float32), e)
6155 }
6156 func (_ fastpathT) EncMapUintFloat32V(v map[uint]float32, e *Encoder) {
6157         if v == nil {
6158                 e.e.EncodeNil()
6159                 return
6160         }
6161         ee, esep := e.e, e.hh.hasElemSeparators()
6162         ee.WriteMapStart(len(v))
6163         if e.h.Canonical {
6164                 v2 := make([]uint64, len(v))
6165                 var i int
6166                 for k, _ := range v {
6167                         v2[i] = uint64(k)
6168                         i++
6169                 }
6170                 sort.Sort(uintSlice(v2))
6171                 if esep {
6172                         for _, k2 := range v2 {
6173                                 ee.WriteMapElemKey()
6174                                 ee.EncodeUint(uint64(uint(k2)))
6175                                 ee.WriteMapElemValue()
6176                                 ee.EncodeFloat32(v[uint(k2)])
6177                         }
6178                 } else {
6179                         for _, k2 := range v2 {
6180                                 ee.EncodeUint(uint64(uint(k2)))
6181                                 ee.EncodeFloat32(v[uint(k2)])
6182                         }
6183                 }
6184         } else {
6185                 if esep {
6186                         for k2, v2 := range v {
6187                                 ee.WriteMapElemKey()
6188                                 ee.EncodeUint(uint64(k2))
6189                                 ee.WriteMapElemValue()
6190                                 ee.EncodeFloat32(v2)
6191                         }
6192                 } else {
6193                         for k2, v2 := range v {
6194                                 ee.EncodeUint(uint64(k2))
6195                                 ee.EncodeFloat32(v2)
6196                         }
6197                 }
6198         }
6199         ee.WriteMapEnd()
6200 }
6201
6202 func (e *Encoder) fastpathEncMapUintFloat64R(f *codecFnInfo, rv reflect.Value) {
6203         fastpathTV.EncMapUintFloat64V(rv2i(rv).(map[uint]float64), e)
6204 }
6205 func (_ fastpathT) EncMapUintFloat64V(v map[uint]float64, e *Encoder) {
6206         if v == nil {
6207                 e.e.EncodeNil()
6208                 return
6209         }
6210         ee, esep := e.e, e.hh.hasElemSeparators()
6211         ee.WriteMapStart(len(v))
6212         if e.h.Canonical {
6213                 v2 := make([]uint64, len(v))
6214                 var i int
6215                 for k, _ := range v {
6216                         v2[i] = uint64(k)
6217                         i++
6218                 }
6219                 sort.Sort(uintSlice(v2))
6220                 if esep {
6221                         for _, k2 := range v2 {
6222                                 ee.WriteMapElemKey()
6223                                 ee.EncodeUint(uint64(uint(k2)))
6224                                 ee.WriteMapElemValue()
6225                                 ee.EncodeFloat64(v[uint(k2)])
6226                         }
6227                 } else {
6228                         for _, k2 := range v2 {
6229                                 ee.EncodeUint(uint64(uint(k2)))
6230                                 ee.EncodeFloat64(v[uint(k2)])
6231                         }
6232                 }
6233         } else {
6234                 if esep {
6235                         for k2, v2 := range v {
6236                                 ee.WriteMapElemKey()
6237                                 ee.EncodeUint(uint64(k2))
6238                                 ee.WriteMapElemValue()
6239                                 ee.EncodeFloat64(v2)
6240                         }
6241                 } else {
6242                         for k2, v2 := range v {
6243                                 ee.EncodeUint(uint64(k2))
6244                                 ee.EncodeFloat64(v2)
6245                         }
6246                 }
6247         }
6248         ee.WriteMapEnd()
6249 }
6250
6251 func (e *Encoder) fastpathEncMapUintBoolR(f *codecFnInfo, rv reflect.Value) {
6252         fastpathTV.EncMapUintBoolV(rv2i(rv).(map[uint]bool), e)
6253 }
6254 func (_ fastpathT) EncMapUintBoolV(v map[uint]bool, e *Encoder) {
6255         if v == nil {
6256                 e.e.EncodeNil()
6257                 return
6258         }
6259         ee, esep := e.e, e.hh.hasElemSeparators()
6260         ee.WriteMapStart(len(v))
6261         if e.h.Canonical {
6262                 v2 := make([]uint64, len(v))
6263                 var i int
6264                 for k, _ := range v {
6265                         v2[i] = uint64(k)
6266                         i++
6267                 }
6268                 sort.Sort(uintSlice(v2))
6269                 if esep {
6270                         for _, k2 := range v2 {
6271                                 ee.WriteMapElemKey()
6272                                 ee.EncodeUint(uint64(uint(k2)))
6273                                 ee.WriteMapElemValue()
6274                                 ee.EncodeBool(v[uint(k2)])
6275                         }
6276                 } else {
6277                         for _, k2 := range v2 {
6278                                 ee.EncodeUint(uint64(uint(k2)))
6279                                 ee.EncodeBool(v[uint(k2)])
6280                         }
6281                 }
6282         } else {
6283                 if esep {
6284                         for k2, v2 := range v {
6285                                 ee.WriteMapElemKey()
6286                                 ee.EncodeUint(uint64(k2))
6287                                 ee.WriteMapElemValue()
6288                                 ee.EncodeBool(v2)
6289                         }
6290                 } else {
6291                         for k2, v2 := range v {
6292                                 ee.EncodeUint(uint64(k2))
6293                                 ee.EncodeBool(v2)
6294                         }
6295                 }
6296         }
6297         ee.WriteMapEnd()
6298 }
6299
6300 func (e *Encoder) fastpathEncMapUint8IntfR(f *codecFnInfo, rv reflect.Value) {
6301         fastpathTV.EncMapUint8IntfV(rv2i(rv).(map[uint8]interface{}), e)
6302 }
6303 func (_ fastpathT) EncMapUint8IntfV(v map[uint8]interface{}, e *Encoder) {
6304         if v == nil {
6305                 e.e.EncodeNil()
6306                 return
6307         }
6308         ee, esep := e.e, e.hh.hasElemSeparators()
6309         ee.WriteMapStart(len(v))
6310         if e.h.Canonical {
6311                 v2 := make([]uint64, len(v))
6312                 var i int
6313                 for k, _ := range v {
6314                         v2[i] = uint64(k)
6315                         i++
6316                 }
6317                 sort.Sort(uintSlice(v2))
6318                 if esep {
6319                         for _, k2 := range v2 {
6320                                 ee.WriteMapElemKey()
6321                                 ee.EncodeUint(uint64(uint8(k2)))
6322                                 ee.WriteMapElemValue()
6323                                 e.encode(v[uint8(k2)])
6324                         }
6325                 } else {
6326                         for _, k2 := range v2 {
6327                                 ee.EncodeUint(uint64(uint8(k2)))
6328                                 e.encode(v[uint8(k2)])
6329                         }
6330                 }
6331         } else {
6332                 if esep {
6333                         for k2, v2 := range v {
6334                                 ee.WriteMapElemKey()
6335                                 ee.EncodeUint(uint64(k2))
6336                                 ee.WriteMapElemValue()
6337                                 e.encode(v2)
6338                         }
6339                 } else {
6340                         for k2, v2 := range v {
6341                                 ee.EncodeUint(uint64(k2))
6342                                 e.encode(v2)
6343                         }
6344                 }
6345         }
6346         ee.WriteMapEnd()
6347 }
6348
6349 func (e *Encoder) fastpathEncMapUint8StringR(f *codecFnInfo, rv reflect.Value) {
6350         fastpathTV.EncMapUint8StringV(rv2i(rv).(map[uint8]string), e)
6351 }
6352 func (_ fastpathT) EncMapUint8StringV(v map[uint8]string, e *Encoder) {
6353         if v == nil {
6354                 e.e.EncodeNil()
6355                 return
6356         }
6357         ee, esep := e.e, e.hh.hasElemSeparators()
6358         ee.WriteMapStart(len(v))
6359         if e.h.Canonical {
6360                 v2 := make([]uint64, len(v))
6361                 var i int
6362                 for k, _ := range v {
6363                         v2[i] = uint64(k)
6364                         i++
6365                 }
6366                 sort.Sort(uintSlice(v2))
6367                 if esep {
6368                         for _, k2 := range v2 {
6369                                 ee.WriteMapElemKey()
6370                                 ee.EncodeUint(uint64(uint8(k2)))
6371                                 ee.WriteMapElemValue()
6372                                 ee.EncodeString(cUTF8, v[uint8(k2)])
6373                         }
6374                 } else {
6375                         for _, k2 := range v2 {
6376                                 ee.EncodeUint(uint64(uint8(k2)))
6377                                 ee.EncodeString(cUTF8, v[uint8(k2)])
6378                         }
6379                 }
6380         } else {
6381                 if esep {
6382                         for k2, v2 := range v {
6383                                 ee.WriteMapElemKey()
6384                                 ee.EncodeUint(uint64(k2))
6385                                 ee.WriteMapElemValue()
6386                                 ee.EncodeString(cUTF8, v2)
6387                         }
6388                 } else {
6389                         for k2, v2 := range v {
6390                                 ee.EncodeUint(uint64(k2))
6391                                 ee.EncodeString(cUTF8, v2)
6392                         }
6393                 }
6394         }
6395         ee.WriteMapEnd()
6396 }
6397
6398 func (e *Encoder) fastpathEncMapUint8UintR(f *codecFnInfo, rv reflect.Value) {
6399         fastpathTV.EncMapUint8UintV(rv2i(rv).(map[uint8]uint), e)
6400 }
6401 func (_ fastpathT) EncMapUint8UintV(v map[uint8]uint, e *Encoder) {
6402         if v == nil {
6403                 e.e.EncodeNil()
6404                 return
6405         }
6406         ee, esep := e.e, e.hh.hasElemSeparators()
6407         ee.WriteMapStart(len(v))
6408         if e.h.Canonical {
6409                 v2 := make([]uint64, len(v))
6410                 var i int
6411                 for k, _ := range v {
6412                         v2[i] = uint64(k)
6413                         i++
6414                 }
6415                 sort.Sort(uintSlice(v2))
6416                 if esep {
6417                         for _, k2 := range v2 {
6418                                 ee.WriteMapElemKey()
6419                                 ee.EncodeUint(uint64(uint8(k2)))
6420                                 ee.WriteMapElemValue()
6421                                 ee.EncodeUint(uint64(v[uint8(k2)]))
6422                         }
6423                 } else {
6424                         for _, k2 := range v2 {
6425                                 ee.EncodeUint(uint64(uint8(k2)))
6426                                 ee.EncodeUint(uint64(v[uint8(k2)]))
6427                         }
6428                 }
6429         } else {
6430                 if esep {
6431                         for k2, v2 := range v {
6432                                 ee.WriteMapElemKey()
6433                                 ee.EncodeUint(uint64(k2))
6434                                 ee.WriteMapElemValue()
6435                                 ee.EncodeUint(uint64(v2))
6436                         }
6437                 } else {
6438                         for k2, v2 := range v {
6439                                 ee.EncodeUint(uint64(k2))
6440                                 ee.EncodeUint(uint64(v2))
6441                         }
6442                 }
6443         }
6444         ee.WriteMapEnd()
6445 }
6446
6447 func (e *Encoder) fastpathEncMapUint8Uint8R(f *codecFnInfo, rv reflect.Value) {
6448         fastpathTV.EncMapUint8Uint8V(rv2i(rv).(map[uint8]uint8), e)
6449 }
6450 func (_ fastpathT) EncMapUint8Uint8V(v map[uint8]uint8, e *Encoder) {
6451         if v == nil {
6452                 e.e.EncodeNil()
6453                 return
6454         }
6455         ee, esep := e.e, e.hh.hasElemSeparators()
6456         ee.WriteMapStart(len(v))
6457         if e.h.Canonical {
6458                 v2 := make([]uint64, len(v))
6459                 var i int
6460                 for k, _ := range v {
6461                         v2[i] = uint64(k)
6462                         i++
6463                 }
6464                 sort.Sort(uintSlice(v2))
6465                 if esep {
6466                         for _, k2 := range v2 {
6467                                 ee.WriteMapElemKey()
6468                                 ee.EncodeUint(uint64(uint8(k2)))
6469                                 ee.WriteMapElemValue()
6470                                 ee.EncodeUint(uint64(v[uint8(k2)]))
6471                         }
6472                 } else {
6473                         for _, k2 := range v2 {
6474                                 ee.EncodeUint(uint64(uint8(k2)))
6475                                 ee.EncodeUint(uint64(v[uint8(k2)]))
6476                         }
6477                 }
6478         } else {
6479                 if esep {
6480                         for k2, v2 := range v {
6481                                 ee.WriteMapElemKey()
6482                                 ee.EncodeUint(uint64(k2))
6483                                 ee.WriteMapElemValue()
6484                                 ee.EncodeUint(uint64(v2))
6485                         }
6486                 } else {
6487                         for k2, v2 := range v {
6488                                 ee.EncodeUint(uint64(k2))
6489                                 ee.EncodeUint(uint64(v2))
6490                         }
6491                 }
6492         }
6493         ee.WriteMapEnd()
6494 }
6495
6496 func (e *Encoder) fastpathEncMapUint8Uint16R(f *codecFnInfo, rv reflect.Value) {
6497         fastpathTV.EncMapUint8Uint16V(rv2i(rv).(map[uint8]uint16), e)
6498 }
6499 func (_ fastpathT) EncMapUint8Uint16V(v map[uint8]uint16, e *Encoder) {
6500         if v == nil {
6501                 e.e.EncodeNil()
6502                 return
6503         }
6504         ee, esep := e.e, e.hh.hasElemSeparators()
6505         ee.WriteMapStart(len(v))
6506         if e.h.Canonical {
6507                 v2 := make([]uint64, len(v))
6508                 var i int
6509                 for k, _ := range v {
6510                         v2[i] = uint64(k)
6511                         i++
6512                 }
6513                 sort.Sort(uintSlice(v2))
6514                 if esep {
6515                         for _, k2 := range v2 {
6516                                 ee.WriteMapElemKey()
6517                                 ee.EncodeUint(uint64(uint8(k2)))
6518                                 ee.WriteMapElemValue()
6519                                 ee.EncodeUint(uint64(v[uint8(k2)]))
6520                         }
6521                 } else {
6522                         for _, k2 := range v2 {
6523                                 ee.EncodeUint(uint64(uint8(k2)))
6524                                 ee.EncodeUint(uint64(v[uint8(k2)]))
6525                         }
6526                 }
6527         } else {
6528                 if esep {
6529                         for k2, v2 := range v {
6530                                 ee.WriteMapElemKey()
6531                                 ee.EncodeUint(uint64(k2))
6532                                 ee.WriteMapElemValue()
6533                                 ee.EncodeUint(uint64(v2))
6534                         }
6535                 } else {
6536                         for k2, v2 := range v {
6537                                 ee.EncodeUint(uint64(k2))
6538                                 ee.EncodeUint(uint64(v2))
6539                         }
6540                 }
6541         }
6542         ee.WriteMapEnd()
6543 }
6544
6545 func (e *Encoder) fastpathEncMapUint8Uint32R(f *codecFnInfo, rv reflect.Value) {
6546         fastpathTV.EncMapUint8Uint32V(rv2i(rv).(map[uint8]uint32), e)
6547 }
6548 func (_ fastpathT) EncMapUint8Uint32V(v map[uint8]uint32, e *Encoder) {
6549         if v == nil {
6550                 e.e.EncodeNil()
6551                 return
6552         }
6553         ee, esep := e.e, e.hh.hasElemSeparators()
6554         ee.WriteMapStart(len(v))
6555         if e.h.Canonical {
6556                 v2 := make([]uint64, len(v))
6557                 var i int
6558                 for k, _ := range v {
6559                         v2[i] = uint64(k)
6560                         i++
6561                 }
6562                 sort.Sort(uintSlice(v2))
6563                 if esep {
6564                         for _, k2 := range v2 {
6565                                 ee.WriteMapElemKey()
6566                                 ee.EncodeUint(uint64(uint8(k2)))
6567                                 ee.WriteMapElemValue()
6568                                 ee.EncodeUint(uint64(v[uint8(k2)]))
6569                         }
6570                 } else {
6571                         for _, k2 := range v2 {
6572                                 ee.EncodeUint(uint64(uint8(k2)))
6573                                 ee.EncodeUint(uint64(v[uint8(k2)]))
6574                         }
6575                 }
6576         } else {
6577                 if esep {
6578                         for k2, v2 := range v {
6579                                 ee.WriteMapElemKey()
6580                                 ee.EncodeUint(uint64(k2))
6581                                 ee.WriteMapElemValue()
6582                                 ee.EncodeUint(uint64(v2))
6583                         }
6584                 } else {
6585                         for k2, v2 := range v {
6586                                 ee.EncodeUint(uint64(k2))
6587                                 ee.EncodeUint(uint64(v2))
6588                         }
6589                 }
6590         }
6591         ee.WriteMapEnd()
6592 }
6593
6594 func (e *Encoder) fastpathEncMapUint8Uint64R(f *codecFnInfo, rv reflect.Value) {
6595         fastpathTV.EncMapUint8Uint64V(rv2i(rv).(map[uint8]uint64), e)
6596 }
6597 func (_ fastpathT) EncMapUint8Uint64V(v map[uint8]uint64, e *Encoder) {
6598         if v == nil {
6599                 e.e.EncodeNil()
6600                 return
6601         }
6602         ee, esep := e.e, e.hh.hasElemSeparators()
6603         ee.WriteMapStart(len(v))
6604         if e.h.Canonical {
6605                 v2 := make([]uint64, len(v))
6606                 var i int
6607                 for k, _ := range v {
6608                         v2[i] = uint64(k)
6609                         i++
6610                 }
6611                 sort.Sort(uintSlice(v2))
6612                 if esep {
6613                         for _, k2 := range v2 {
6614                                 ee.WriteMapElemKey()
6615                                 ee.EncodeUint(uint64(uint8(k2)))
6616                                 ee.WriteMapElemValue()
6617                                 ee.EncodeUint(uint64(v[uint8(k2)]))
6618                         }
6619                 } else {
6620                         for _, k2 := range v2 {
6621                                 ee.EncodeUint(uint64(uint8(k2)))
6622                                 ee.EncodeUint(uint64(v[uint8(k2)]))
6623                         }
6624                 }
6625         } else {
6626                 if esep {
6627                         for k2, v2 := range v {
6628                                 ee.WriteMapElemKey()
6629                                 ee.EncodeUint(uint64(k2))
6630                                 ee.WriteMapElemValue()
6631                                 ee.EncodeUint(uint64(v2))
6632                         }
6633                 } else {
6634                         for k2, v2 := range v {
6635                                 ee.EncodeUint(uint64(k2))
6636                                 ee.EncodeUint(uint64(v2))
6637                         }
6638                 }
6639         }
6640         ee.WriteMapEnd()
6641 }
6642
6643 func (e *Encoder) fastpathEncMapUint8UintptrR(f *codecFnInfo, rv reflect.Value) {
6644         fastpathTV.EncMapUint8UintptrV(rv2i(rv).(map[uint8]uintptr), e)
6645 }
6646 func (_ fastpathT) EncMapUint8UintptrV(v map[uint8]uintptr, e *Encoder) {
6647         if v == nil {
6648                 e.e.EncodeNil()
6649                 return
6650         }
6651         ee, esep := e.e, e.hh.hasElemSeparators()
6652         ee.WriteMapStart(len(v))
6653         if e.h.Canonical {
6654                 v2 := make([]uint64, len(v))
6655                 var i int
6656                 for k, _ := range v {
6657                         v2[i] = uint64(k)
6658                         i++
6659                 }
6660                 sort.Sort(uintSlice(v2))
6661                 if esep {
6662                         for _, k2 := range v2 {
6663                                 ee.WriteMapElemKey()
6664                                 ee.EncodeUint(uint64(uint8(k2)))
6665                                 ee.WriteMapElemValue()
6666                                 e.encode(v[uint8(k2)])
6667                         }
6668                 } else {
6669                         for _, k2 := range v2 {
6670                                 ee.EncodeUint(uint64(uint8(k2)))
6671                                 e.encode(v[uint8(k2)])
6672                         }
6673                 }
6674         } else {
6675                 if esep {
6676                         for k2, v2 := range v {
6677                                 ee.WriteMapElemKey()
6678                                 ee.EncodeUint(uint64(k2))
6679                                 ee.WriteMapElemValue()
6680                                 e.encode(v2)
6681                         }
6682                 } else {
6683                         for k2, v2 := range v {
6684                                 ee.EncodeUint(uint64(k2))
6685                                 e.encode(v2)
6686                         }
6687                 }
6688         }
6689         ee.WriteMapEnd()
6690 }
6691
6692 func (e *Encoder) fastpathEncMapUint8IntR(f *codecFnInfo, rv reflect.Value) {
6693         fastpathTV.EncMapUint8IntV(rv2i(rv).(map[uint8]int), e)
6694 }
6695 func (_ fastpathT) EncMapUint8IntV(v map[uint8]int, e *Encoder) {
6696         if v == nil {
6697                 e.e.EncodeNil()
6698                 return
6699         }
6700         ee, esep := e.e, e.hh.hasElemSeparators()
6701         ee.WriteMapStart(len(v))
6702         if e.h.Canonical {
6703                 v2 := make([]uint64, len(v))
6704                 var i int
6705                 for k, _ := range v {
6706                         v2[i] = uint64(k)
6707                         i++
6708                 }
6709                 sort.Sort(uintSlice(v2))
6710                 if esep {
6711                         for _, k2 := range v2 {
6712                                 ee.WriteMapElemKey()
6713                                 ee.EncodeUint(uint64(uint8(k2)))
6714                                 ee.WriteMapElemValue()
6715                                 ee.EncodeInt(int64(v[uint8(k2)]))
6716                         }
6717                 } else {
6718                         for _, k2 := range v2 {
6719                                 ee.EncodeUint(uint64(uint8(k2)))
6720                                 ee.EncodeInt(int64(v[uint8(k2)]))
6721                         }
6722                 }
6723         } else {
6724                 if esep {
6725                         for k2, v2 := range v {
6726                                 ee.WriteMapElemKey()
6727                                 ee.EncodeUint(uint64(k2))
6728                                 ee.WriteMapElemValue()
6729                                 ee.EncodeInt(int64(v2))
6730                         }
6731                 } else {
6732                         for k2, v2 := range v {
6733                                 ee.EncodeUint(uint64(k2))
6734                                 ee.EncodeInt(int64(v2))
6735                         }
6736                 }
6737         }
6738         ee.WriteMapEnd()
6739 }
6740
6741 func (e *Encoder) fastpathEncMapUint8Int8R(f *codecFnInfo, rv reflect.Value) {
6742         fastpathTV.EncMapUint8Int8V(rv2i(rv).(map[uint8]int8), e)
6743 }
6744 func (_ fastpathT) EncMapUint8Int8V(v map[uint8]int8, e *Encoder) {
6745         if v == nil {
6746                 e.e.EncodeNil()
6747                 return
6748         }
6749         ee, esep := e.e, e.hh.hasElemSeparators()
6750         ee.WriteMapStart(len(v))
6751         if e.h.Canonical {
6752                 v2 := make([]uint64, len(v))
6753                 var i int
6754                 for k, _ := range v {
6755                         v2[i] = uint64(k)
6756                         i++
6757                 }
6758                 sort.Sort(uintSlice(v2))
6759                 if esep {
6760                         for _, k2 := range v2 {
6761                                 ee.WriteMapElemKey()
6762                                 ee.EncodeUint(uint64(uint8(k2)))
6763                                 ee.WriteMapElemValue()
6764                                 ee.EncodeInt(int64(v[uint8(k2)]))
6765                         }
6766                 } else {
6767                         for _, k2 := range v2 {
6768                                 ee.EncodeUint(uint64(uint8(k2)))
6769                                 ee.EncodeInt(int64(v[uint8(k2)]))
6770                         }
6771                 }
6772         } else {
6773                 if esep {
6774                         for k2, v2 := range v {
6775                                 ee.WriteMapElemKey()
6776                                 ee.EncodeUint(uint64(k2))
6777                                 ee.WriteMapElemValue()
6778                                 ee.EncodeInt(int64(v2))
6779                         }
6780                 } else {
6781                         for k2, v2 := range v {
6782                                 ee.EncodeUint(uint64(k2))
6783                                 ee.EncodeInt(int64(v2))
6784                         }
6785                 }
6786         }
6787         ee.WriteMapEnd()
6788 }
6789
6790 func (e *Encoder) fastpathEncMapUint8Int16R(f *codecFnInfo, rv reflect.Value) {
6791         fastpathTV.EncMapUint8Int16V(rv2i(rv).(map[uint8]int16), e)
6792 }
6793 func (_ fastpathT) EncMapUint8Int16V(v map[uint8]int16, e *Encoder) {
6794         if v == nil {
6795                 e.e.EncodeNil()
6796                 return
6797         }
6798         ee, esep := e.e, e.hh.hasElemSeparators()
6799         ee.WriteMapStart(len(v))
6800         if e.h.Canonical {
6801                 v2 := make([]uint64, len(v))
6802                 var i int
6803                 for k, _ := range v {
6804                         v2[i] = uint64(k)
6805                         i++
6806                 }
6807                 sort.Sort(uintSlice(v2))
6808                 if esep {
6809                         for _, k2 := range v2 {
6810                                 ee.WriteMapElemKey()
6811                                 ee.EncodeUint(uint64(uint8(k2)))
6812                                 ee.WriteMapElemValue()
6813                                 ee.EncodeInt(int64(v[uint8(k2)]))
6814                         }
6815                 } else {
6816                         for _, k2 := range v2 {
6817                                 ee.EncodeUint(uint64(uint8(k2)))
6818                                 ee.EncodeInt(int64(v[uint8(k2)]))
6819                         }
6820                 }
6821         } else {
6822                 if esep {
6823                         for k2, v2 := range v {
6824                                 ee.WriteMapElemKey()
6825                                 ee.EncodeUint(uint64(k2))
6826                                 ee.WriteMapElemValue()
6827                                 ee.EncodeInt(int64(v2))
6828                         }
6829                 } else {
6830                         for k2, v2 := range v {
6831                                 ee.EncodeUint(uint64(k2))
6832                                 ee.EncodeInt(int64(v2))
6833                         }
6834                 }
6835         }
6836         ee.WriteMapEnd()
6837 }
6838
6839 func (e *Encoder) fastpathEncMapUint8Int32R(f *codecFnInfo, rv reflect.Value) {
6840         fastpathTV.EncMapUint8Int32V(rv2i(rv).(map[uint8]int32), e)
6841 }
6842 func (_ fastpathT) EncMapUint8Int32V(v map[uint8]int32, e *Encoder) {
6843         if v == nil {
6844                 e.e.EncodeNil()
6845                 return
6846         }
6847         ee, esep := e.e, e.hh.hasElemSeparators()
6848         ee.WriteMapStart(len(v))
6849         if e.h.Canonical {
6850                 v2 := make([]uint64, len(v))
6851                 var i int
6852                 for k, _ := range v {
6853                         v2[i] = uint64(k)
6854                         i++
6855                 }
6856                 sort.Sort(uintSlice(v2))
6857                 if esep {
6858                         for _, k2 := range v2 {
6859                                 ee.WriteMapElemKey()
6860                                 ee.EncodeUint(uint64(uint8(k2)))
6861                                 ee.WriteMapElemValue()
6862                                 ee.EncodeInt(int64(v[uint8(k2)]))
6863                         }
6864                 } else {
6865                         for _, k2 := range v2 {
6866                                 ee.EncodeUint(uint64(uint8(k2)))
6867                                 ee.EncodeInt(int64(v[uint8(k2)]))
6868                         }
6869                 }
6870         } else {
6871                 if esep {
6872                         for k2, v2 := range v {
6873                                 ee.WriteMapElemKey()
6874                                 ee.EncodeUint(uint64(k2))
6875                                 ee.WriteMapElemValue()
6876                                 ee.EncodeInt(int64(v2))
6877                         }
6878                 } else {
6879                         for k2, v2 := range v {
6880                                 ee.EncodeUint(uint64(k2))
6881                                 ee.EncodeInt(int64(v2))
6882                         }
6883                 }
6884         }
6885         ee.WriteMapEnd()
6886 }
6887
6888 func (e *Encoder) fastpathEncMapUint8Int64R(f *codecFnInfo, rv reflect.Value) {
6889         fastpathTV.EncMapUint8Int64V(rv2i(rv).(map[uint8]int64), e)
6890 }
6891 func (_ fastpathT) EncMapUint8Int64V(v map[uint8]int64, e *Encoder) {
6892         if v == nil {
6893                 e.e.EncodeNil()
6894                 return
6895         }
6896         ee, esep := e.e, e.hh.hasElemSeparators()
6897         ee.WriteMapStart(len(v))
6898         if e.h.Canonical {
6899                 v2 := make([]uint64, len(v))
6900                 var i int
6901                 for k, _ := range v {
6902                         v2[i] = uint64(k)
6903                         i++
6904                 }
6905                 sort.Sort(uintSlice(v2))
6906                 if esep {
6907                         for _, k2 := range v2 {
6908                                 ee.WriteMapElemKey()
6909                                 ee.EncodeUint(uint64(uint8(k2)))
6910                                 ee.WriteMapElemValue()
6911                                 ee.EncodeInt(int64(v[uint8(k2)]))
6912                         }
6913                 } else {
6914                         for _, k2 := range v2 {
6915                                 ee.EncodeUint(uint64(uint8(k2)))
6916                                 ee.EncodeInt(int64(v[uint8(k2)]))
6917                         }
6918                 }
6919         } else {
6920                 if esep {
6921                         for k2, v2 := range v {
6922                                 ee.WriteMapElemKey()
6923                                 ee.EncodeUint(uint64(k2))
6924                                 ee.WriteMapElemValue()
6925                                 ee.EncodeInt(int64(v2))
6926                         }
6927                 } else {
6928                         for k2, v2 := range v {
6929                                 ee.EncodeUint(uint64(k2))
6930                                 ee.EncodeInt(int64(v2))
6931                         }
6932                 }
6933         }
6934         ee.WriteMapEnd()
6935 }
6936
6937 func (e *Encoder) fastpathEncMapUint8Float32R(f *codecFnInfo, rv reflect.Value) {
6938         fastpathTV.EncMapUint8Float32V(rv2i(rv).(map[uint8]float32), e)
6939 }
6940 func (_ fastpathT) EncMapUint8Float32V(v map[uint8]float32, e *Encoder) {
6941         if v == nil {
6942                 e.e.EncodeNil()
6943                 return
6944         }
6945         ee, esep := e.e, e.hh.hasElemSeparators()
6946         ee.WriteMapStart(len(v))
6947         if e.h.Canonical {
6948                 v2 := make([]uint64, len(v))
6949                 var i int
6950                 for k, _ := range v {
6951                         v2[i] = uint64(k)
6952                         i++
6953                 }
6954                 sort.Sort(uintSlice(v2))
6955                 if esep {
6956                         for _, k2 := range v2 {
6957                                 ee.WriteMapElemKey()
6958                                 ee.EncodeUint(uint64(uint8(k2)))
6959                                 ee.WriteMapElemValue()
6960                                 ee.EncodeFloat32(v[uint8(k2)])
6961                         }
6962                 } else {
6963                         for _, k2 := range v2 {
6964                                 ee.EncodeUint(uint64(uint8(k2)))
6965                                 ee.EncodeFloat32(v[uint8(k2)])
6966                         }
6967                 }
6968         } else {
6969                 if esep {
6970                         for k2, v2 := range v {
6971                                 ee.WriteMapElemKey()
6972                                 ee.EncodeUint(uint64(k2))
6973                                 ee.WriteMapElemValue()
6974                                 ee.EncodeFloat32(v2)
6975                         }
6976                 } else {
6977                         for k2, v2 := range v {
6978                                 ee.EncodeUint(uint64(k2))
6979                                 ee.EncodeFloat32(v2)
6980                         }
6981                 }
6982         }
6983         ee.WriteMapEnd()
6984 }
6985
6986 func (e *Encoder) fastpathEncMapUint8Float64R(f *codecFnInfo, rv reflect.Value) {
6987         fastpathTV.EncMapUint8Float64V(rv2i(rv).(map[uint8]float64), e)
6988 }
6989 func (_ fastpathT) EncMapUint8Float64V(v map[uint8]float64, e *Encoder) {
6990         if v == nil {
6991                 e.e.EncodeNil()
6992                 return
6993         }
6994         ee, esep := e.e, e.hh.hasElemSeparators()
6995         ee.WriteMapStart(len(v))
6996         if e.h.Canonical {
6997                 v2 := make([]uint64, len(v))
6998                 var i int
6999                 for k, _ := range v {
7000                         v2[i] = uint64(k)
7001                         i++
7002                 }
7003                 sort.Sort(uintSlice(v2))
7004                 if esep {
7005                         for _, k2 := range v2 {
7006                                 ee.WriteMapElemKey()
7007                                 ee.EncodeUint(uint64(uint8(k2)))
7008                                 ee.WriteMapElemValue()
7009                                 ee.EncodeFloat64(v[uint8(k2)])
7010                         }
7011                 } else {
7012                         for _, k2 := range v2 {
7013                                 ee.EncodeUint(uint64(uint8(k2)))
7014                                 ee.EncodeFloat64(v[uint8(k2)])
7015                         }
7016                 }
7017         } else {
7018                 if esep {
7019                         for k2, v2 := range v {
7020                                 ee.WriteMapElemKey()
7021                                 ee.EncodeUint(uint64(k2))
7022                                 ee.WriteMapElemValue()
7023                                 ee.EncodeFloat64(v2)
7024                         }
7025                 } else {
7026                         for k2, v2 := range v {
7027                                 ee.EncodeUint(uint64(k2))
7028                                 ee.EncodeFloat64(v2)
7029                         }
7030                 }
7031         }
7032         ee.WriteMapEnd()
7033 }
7034
7035 func (e *Encoder) fastpathEncMapUint8BoolR(f *codecFnInfo, rv reflect.Value) {
7036         fastpathTV.EncMapUint8BoolV(rv2i(rv).(map[uint8]bool), e)
7037 }
7038 func (_ fastpathT) EncMapUint8BoolV(v map[uint8]bool, e *Encoder) {
7039         if v == nil {
7040                 e.e.EncodeNil()
7041                 return
7042         }
7043         ee, esep := e.e, e.hh.hasElemSeparators()
7044         ee.WriteMapStart(len(v))
7045         if e.h.Canonical {
7046                 v2 := make([]uint64, len(v))
7047                 var i int
7048                 for k, _ := range v {
7049                         v2[i] = uint64(k)
7050                         i++
7051                 }
7052                 sort.Sort(uintSlice(v2))
7053                 if esep {
7054                         for _, k2 := range v2 {
7055                                 ee.WriteMapElemKey()
7056                                 ee.EncodeUint(uint64(uint8(k2)))
7057                                 ee.WriteMapElemValue()
7058                                 ee.EncodeBool(v[uint8(k2)])
7059                         }
7060                 } else {
7061                         for _, k2 := range v2 {
7062                                 ee.EncodeUint(uint64(uint8(k2)))
7063                                 ee.EncodeBool(v[uint8(k2)])
7064                         }
7065                 }
7066         } else {
7067                 if esep {
7068                         for k2, v2 := range v {
7069                                 ee.WriteMapElemKey()
7070                                 ee.EncodeUint(uint64(k2))
7071                                 ee.WriteMapElemValue()
7072                                 ee.EncodeBool(v2)
7073                         }
7074                 } else {
7075                         for k2, v2 := range v {
7076                                 ee.EncodeUint(uint64(k2))
7077                                 ee.EncodeBool(v2)
7078                         }
7079                 }
7080         }
7081         ee.WriteMapEnd()
7082 }
7083
7084 func (e *Encoder) fastpathEncMapUint16IntfR(f *codecFnInfo, rv reflect.Value) {
7085         fastpathTV.EncMapUint16IntfV(rv2i(rv).(map[uint16]interface{}), e)
7086 }
7087 func (_ fastpathT) EncMapUint16IntfV(v map[uint16]interface{}, e *Encoder) {
7088         if v == nil {
7089                 e.e.EncodeNil()
7090                 return
7091         }
7092         ee, esep := e.e, e.hh.hasElemSeparators()
7093         ee.WriteMapStart(len(v))
7094         if e.h.Canonical {
7095                 v2 := make([]uint64, len(v))
7096                 var i int
7097                 for k, _ := range v {
7098                         v2[i] = uint64(k)
7099                         i++
7100                 }
7101                 sort.Sort(uintSlice(v2))
7102                 if esep {
7103                         for _, k2 := range v2 {
7104                                 ee.WriteMapElemKey()
7105                                 ee.EncodeUint(uint64(uint16(k2)))
7106                                 ee.WriteMapElemValue()
7107                                 e.encode(v[uint16(k2)])
7108                         }
7109                 } else {
7110                         for _, k2 := range v2 {
7111                                 ee.EncodeUint(uint64(uint16(k2)))
7112                                 e.encode(v[uint16(k2)])
7113                         }
7114                 }
7115         } else {
7116                 if esep {
7117                         for k2, v2 := range v {
7118                                 ee.WriteMapElemKey()
7119                                 ee.EncodeUint(uint64(k2))
7120                                 ee.WriteMapElemValue()
7121                                 e.encode(v2)
7122                         }
7123                 } else {
7124                         for k2, v2 := range v {
7125                                 ee.EncodeUint(uint64(k2))
7126                                 e.encode(v2)
7127                         }
7128                 }
7129         }
7130         ee.WriteMapEnd()
7131 }
7132
7133 func (e *Encoder) fastpathEncMapUint16StringR(f *codecFnInfo, rv reflect.Value) {
7134         fastpathTV.EncMapUint16StringV(rv2i(rv).(map[uint16]string), e)
7135 }
7136 func (_ fastpathT) EncMapUint16StringV(v map[uint16]string, e *Encoder) {
7137         if v == nil {
7138                 e.e.EncodeNil()
7139                 return
7140         }
7141         ee, esep := e.e, e.hh.hasElemSeparators()
7142         ee.WriteMapStart(len(v))
7143         if e.h.Canonical {
7144                 v2 := make([]uint64, len(v))
7145                 var i int
7146                 for k, _ := range v {
7147                         v2[i] = uint64(k)
7148                         i++
7149                 }
7150                 sort.Sort(uintSlice(v2))
7151                 if esep {
7152                         for _, k2 := range v2 {
7153                                 ee.WriteMapElemKey()
7154                                 ee.EncodeUint(uint64(uint16(k2)))
7155                                 ee.WriteMapElemValue()
7156                                 ee.EncodeString(cUTF8, v[uint16(k2)])
7157                         }
7158                 } else {
7159                         for _, k2 := range v2 {
7160                                 ee.EncodeUint(uint64(uint16(k2)))
7161                                 ee.EncodeString(cUTF8, v[uint16(k2)])
7162                         }
7163                 }
7164         } else {
7165                 if esep {
7166                         for k2, v2 := range v {
7167                                 ee.WriteMapElemKey()
7168                                 ee.EncodeUint(uint64(k2))
7169                                 ee.WriteMapElemValue()
7170                                 ee.EncodeString(cUTF8, v2)
7171                         }
7172                 } else {
7173                         for k2, v2 := range v {
7174                                 ee.EncodeUint(uint64(k2))
7175                                 ee.EncodeString(cUTF8, v2)
7176                         }
7177                 }
7178         }
7179         ee.WriteMapEnd()
7180 }
7181
7182 func (e *Encoder) fastpathEncMapUint16UintR(f *codecFnInfo, rv reflect.Value) {
7183         fastpathTV.EncMapUint16UintV(rv2i(rv).(map[uint16]uint), e)
7184 }
7185 func (_ fastpathT) EncMapUint16UintV(v map[uint16]uint, e *Encoder) {
7186         if v == nil {
7187                 e.e.EncodeNil()
7188                 return
7189         }
7190         ee, esep := e.e, e.hh.hasElemSeparators()
7191         ee.WriteMapStart(len(v))
7192         if e.h.Canonical {
7193                 v2 := make([]uint64, len(v))
7194                 var i int
7195                 for k, _ := range v {
7196                         v2[i] = uint64(k)
7197                         i++
7198                 }
7199                 sort.Sort(uintSlice(v2))
7200                 if esep {
7201                         for _, k2 := range v2 {
7202                                 ee.WriteMapElemKey()
7203                                 ee.EncodeUint(uint64(uint16(k2)))
7204                                 ee.WriteMapElemValue()
7205                                 ee.EncodeUint(uint64(v[uint16(k2)]))
7206                         }
7207                 } else {
7208                         for _, k2 := range v2 {
7209                                 ee.EncodeUint(uint64(uint16(k2)))
7210                                 ee.EncodeUint(uint64(v[uint16(k2)]))
7211                         }
7212                 }
7213         } else {
7214                 if esep {
7215                         for k2, v2 := range v {
7216                                 ee.WriteMapElemKey()
7217                                 ee.EncodeUint(uint64(k2))
7218                                 ee.WriteMapElemValue()
7219                                 ee.EncodeUint(uint64(v2))
7220                         }
7221                 } else {
7222                         for k2, v2 := range v {
7223                                 ee.EncodeUint(uint64(k2))
7224                                 ee.EncodeUint(uint64(v2))
7225                         }
7226                 }
7227         }
7228         ee.WriteMapEnd()
7229 }
7230
7231 func (e *Encoder) fastpathEncMapUint16Uint8R(f *codecFnInfo, rv reflect.Value) {
7232         fastpathTV.EncMapUint16Uint8V(rv2i(rv).(map[uint16]uint8), e)
7233 }
7234 func (_ fastpathT) EncMapUint16Uint8V(v map[uint16]uint8, e *Encoder) {
7235         if v == nil {
7236                 e.e.EncodeNil()
7237                 return
7238         }
7239         ee, esep := e.e, e.hh.hasElemSeparators()
7240         ee.WriteMapStart(len(v))
7241         if e.h.Canonical {
7242                 v2 := make([]uint64, len(v))
7243                 var i int
7244                 for k, _ := range v {
7245                         v2[i] = uint64(k)
7246                         i++
7247                 }
7248                 sort.Sort(uintSlice(v2))
7249                 if esep {
7250                         for _, k2 := range v2 {
7251                                 ee.WriteMapElemKey()
7252                                 ee.EncodeUint(uint64(uint16(k2)))
7253                                 ee.WriteMapElemValue()
7254                                 ee.EncodeUint(uint64(v[uint16(k2)]))
7255                         }
7256                 } else {
7257                         for _, k2 := range v2 {
7258                                 ee.EncodeUint(uint64(uint16(k2)))
7259                                 ee.EncodeUint(uint64(v[uint16(k2)]))
7260                         }
7261                 }
7262         } else {
7263                 if esep {
7264                         for k2, v2 := range v {
7265                                 ee.WriteMapElemKey()
7266                                 ee.EncodeUint(uint64(k2))
7267                                 ee.WriteMapElemValue()
7268                                 ee.EncodeUint(uint64(v2))
7269                         }
7270                 } else {
7271                         for k2, v2 := range v {
7272                                 ee.EncodeUint(uint64(k2))
7273                                 ee.EncodeUint(uint64(v2))
7274                         }
7275                 }
7276         }
7277         ee.WriteMapEnd()
7278 }
7279
7280 func (e *Encoder) fastpathEncMapUint16Uint16R(f *codecFnInfo, rv reflect.Value) {
7281         fastpathTV.EncMapUint16Uint16V(rv2i(rv).(map[uint16]uint16), e)
7282 }
7283 func (_ fastpathT) EncMapUint16Uint16V(v map[uint16]uint16, e *Encoder) {
7284         if v == nil {
7285                 e.e.EncodeNil()
7286                 return
7287         }
7288         ee, esep := e.e, e.hh.hasElemSeparators()
7289         ee.WriteMapStart(len(v))
7290         if e.h.Canonical {
7291                 v2 := make([]uint64, len(v))
7292                 var i int
7293                 for k, _ := range v {
7294                         v2[i] = uint64(k)
7295                         i++
7296                 }
7297                 sort.Sort(uintSlice(v2))
7298                 if esep {
7299                         for _, k2 := range v2 {
7300                                 ee.WriteMapElemKey()
7301                                 ee.EncodeUint(uint64(uint16(k2)))
7302                                 ee.WriteMapElemValue()
7303                                 ee.EncodeUint(uint64(v[uint16(k2)]))
7304                         }
7305                 } else {
7306                         for _, k2 := range v2 {
7307                                 ee.EncodeUint(uint64(uint16(k2)))
7308                                 ee.EncodeUint(uint64(v[uint16(k2)]))
7309                         }
7310                 }
7311         } else {
7312                 if esep {
7313                         for k2, v2 := range v {
7314                                 ee.WriteMapElemKey()
7315                                 ee.EncodeUint(uint64(k2))
7316                                 ee.WriteMapElemValue()
7317                                 ee.EncodeUint(uint64(v2))
7318                         }
7319                 } else {
7320                         for k2, v2 := range v {
7321                                 ee.EncodeUint(uint64(k2))
7322                                 ee.EncodeUint(uint64(v2))
7323                         }
7324                 }
7325         }
7326         ee.WriteMapEnd()
7327 }
7328
7329 func (e *Encoder) fastpathEncMapUint16Uint32R(f *codecFnInfo, rv reflect.Value) {
7330         fastpathTV.EncMapUint16Uint32V(rv2i(rv).(map[uint16]uint32), e)
7331 }
7332 func (_ fastpathT) EncMapUint16Uint32V(v map[uint16]uint32, e *Encoder) {
7333         if v == nil {
7334                 e.e.EncodeNil()
7335                 return
7336         }
7337         ee, esep := e.e, e.hh.hasElemSeparators()
7338         ee.WriteMapStart(len(v))
7339         if e.h.Canonical {
7340                 v2 := make([]uint64, len(v))
7341                 var i int
7342                 for k, _ := range v {
7343                         v2[i] = uint64(k)
7344                         i++
7345                 }
7346                 sort.Sort(uintSlice(v2))
7347                 if esep {
7348                         for _, k2 := range v2 {
7349                                 ee.WriteMapElemKey()
7350                                 ee.EncodeUint(uint64(uint16(k2)))
7351                                 ee.WriteMapElemValue()
7352                                 ee.EncodeUint(uint64(v[uint16(k2)]))
7353                         }
7354                 } else {
7355                         for _, k2 := range v2 {
7356                                 ee.EncodeUint(uint64(uint16(k2)))
7357                                 ee.EncodeUint(uint64(v[uint16(k2)]))
7358                         }
7359                 }
7360         } else {
7361                 if esep {
7362                         for k2, v2 := range v {
7363                                 ee.WriteMapElemKey()
7364                                 ee.EncodeUint(uint64(k2))
7365                                 ee.WriteMapElemValue()
7366                                 ee.EncodeUint(uint64(v2))
7367                         }
7368                 } else {
7369                         for k2, v2 := range v {
7370                                 ee.EncodeUint(uint64(k2))
7371                                 ee.EncodeUint(uint64(v2))
7372                         }
7373                 }
7374         }
7375         ee.WriteMapEnd()
7376 }
7377
7378 func (e *Encoder) fastpathEncMapUint16Uint64R(f *codecFnInfo, rv reflect.Value) {
7379         fastpathTV.EncMapUint16Uint64V(rv2i(rv).(map[uint16]uint64), e)
7380 }
7381 func (_ fastpathT) EncMapUint16Uint64V(v map[uint16]uint64, e *Encoder) {
7382         if v == nil {
7383                 e.e.EncodeNil()
7384                 return
7385         }
7386         ee, esep := e.e, e.hh.hasElemSeparators()
7387         ee.WriteMapStart(len(v))
7388         if e.h.Canonical {
7389                 v2 := make([]uint64, len(v))
7390                 var i int
7391                 for k, _ := range v {
7392                         v2[i] = uint64(k)
7393                         i++
7394                 }
7395                 sort.Sort(uintSlice(v2))
7396                 if esep {
7397                         for _, k2 := range v2 {
7398                                 ee.WriteMapElemKey()
7399                                 ee.EncodeUint(uint64(uint16(k2)))
7400                                 ee.WriteMapElemValue()
7401                                 ee.EncodeUint(uint64(v[uint16(k2)]))
7402                         }
7403                 } else {
7404                         for _, k2 := range v2 {
7405                                 ee.EncodeUint(uint64(uint16(k2)))
7406                                 ee.EncodeUint(uint64(v[uint16(k2)]))
7407                         }
7408                 }
7409         } else {
7410                 if esep {
7411                         for k2, v2 := range v {
7412                                 ee.WriteMapElemKey()
7413                                 ee.EncodeUint(uint64(k2))
7414                                 ee.WriteMapElemValue()
7415                                 ee.EncodeUint(uint64(v2))
7416                         }
7417                 } else {
7418                         for k2, v2 := range v {
7419                                 ee.EncodeUint(uint64(k2))
7420                                 ee.EncodeUint(uint64(v2))
7421                         }
7422                 }
7423         }
7424         ee.WriteMapEnd()
7425 }
7426
7427 func (e *Encoder) fastpathEncMapUint16UintptrR(f *codecFnInfo, rv reflect.Value) {
7428         fastpathTV.EncMapUint16UintptrV(rv2i(rv).(map[uint16]uintptr), e)
7429 }
7430 func (_ fastpathT) EncMapUint16UintptrV(v map[uint16]uintptr, e *Encoder) {
7431         if v == nil {
7432                 e.e.EncodeNil()
7433                 return
7434         }
7435         ee, esep := e.e, e.hh.hasElemSeparators()
7436         ee.WriteMapStart(len(v))
7437         if e.h.Canonical {
7438                 v2 := make([]uint64, len(v))
7439                 var i int
7440                 for k, _ := range v {
7441                         v2[i] = uint64(k)
7442                         i++
7443                 }
7444                 sort.Sort(uintSlice(v2))
7445                 if esep {
7446                         for _, k2 := range v2 {
7447                                 ee.WriteMapElemKey()
7448                                 ee.EncodeUint(uint64(uint16(k2)))
7449                                 ee.WriteMapElemValue()
7450                                 e.encode(v[uint16(k2)])
7451                         }
7452                 } else {
7453                         for _, k2 := range v2 {
7454                                 ee.EncodeUint(uint64(uint16(k2)))
7455                                 e.encode(v[uint16(k2)])
7456                         }
7457                 }
7458         } else {
7459                 if esep {
7460                         for k2, v2 := range v {
7461                                 ee.WriteMapElemKey()
7462                                 ee.EncodeUint(uint64(k2))
7463                                 ee.WriteMapElemValue()
7464                                 e.encode(v2)
7465                         }
7466                 } else {
7467                         for k2, v2 := range v {
7468                                 ee.EncodeUint(uint64(k2))
7469                                 e.encode(v2)
7470                         }
7471                 }
7472         }
7473         ee.WriteMapEnd()
7474 }
7475
7476 func (e *Encoder) fastpathEncMapUint16IntR(f *codecFnInfo, rv reflect.Value) {
7477         fastpathTV.EncMapUint16IntV(rv2i(rv).(map[uint16]int), e)
7478 }
7479 func (_ fastpathT) EncMapUint16IntV(v map[uint16]int, e *Encoder) {
7480         if v == nil {
7481                 e.e.EncodeNil()
7482                 return
7483         }
7484         ee, esep := e.e, e.hh.hasElemSeparators()
7485         ee.WriteMapStart(len(v))
7486         if e.h.Canonical {
7487                 v2 := make([]uint64, len(v))
7488                 var i int
7489                 for k, _ := range v {
7490                         v2[i] = uint64(k)
7491                         i++
7492                 }
7493                 sort.Sort(uintSlice(v2))
7494                 if esep {
7495                         for _, k2 := range v2 {
7496                                 ee.WriteMapElemKey()
7497                                 ee.EncodeUint(uint64(uint16(k2)))
7498                                 ee.WriteMapElemValue()
7499                                 ee.EncodeInt(int64(v[uint16(k2)]))
7500                         }
7501                 } else {
7502                         for _, k2 := range v2 {
7503                                 ee.EncodeUint(uint64(uint16(k2)))
7504                                 ee.EncodeInt(int64(v[uint16(k2)]))
7505                         }
7506                 }
7507         } else {
7508                 if esep {
7509                         for k2, v2 := range v {
7510                                 ee.WriteMapElemKey()
7511                                 ee.EncodeUint(uint64(k2))
7512                                 ee.WriteMapElemValue()
7513                                 ee.EncodeInt(int64(v2))
7514                         }
7515                 } else {
7516                         for k2, v2 := range v {
7517                                 ee.EncodeUint(uint64(k2))
7518                                 ee.EncodeInt(int64(v2))
7519                         }
7520                 }
7521         }
7522         ee.WriteMapEnd()
7523 }
7524
7525 func (e *Encoder) fastpathEncMapUint16Int8R(f *codecFnInfo, rv reflect.Value) {
7526         fastpathTV.EncMapUint16Int8V(rv2i(rv).(map[uint16]int8), e)
7527 }
7528 func (_ fastpathT) EncMapUint16Int8V(v map[uint16]int8, e *Encoder) {
7529         if v == nil {
7530                 e.e.EncodeNil()
7531                 return
7532         }
7533         ee, esep := e.e, e.hh.hasElemSeparators()
7534         ee.WriteMapStart(len(v))
7535         if e.h.Canonical {
7536                 v2 := make([]uint64, len(v))
7537                 var i int
7538                 for k, _ := range v {
7539                         v2[i] = uint64(k)
7540                         i++
7541                 }
7542                 sort.Sort(uintSlice(v2))
7543                 if esep {
7544                         for _, k2 := range v2 {
7545                                 ee.WriteMapElemKey()
7546                                 ee.EncodeUint(uint64(uint16(k2)))
7547                                 ee.WriteMapElemValue()
7548                                 ee.EncodeInt(int64(v[uint16(k2)]))
7549                         }
7550                 } else {
7551                         for _, k2 := range v2 {
7552                                 ee.EncodeUint(uint64(uint16(k2)))
7553                                 ee.EncodeInt(int64(v[uint16(k2)]))
7554                         }
7555                 }
7556         } else {
7557                 if esep {
7558                         for k2, v2 := range v {
7559                                 ee.WriteMapElemKey()
7560                                 ee.EncodeUint(uint64(k2))
7561                                 ee.WriteMapElemValue()
7562                                 ee.EncodeInt(int64(v2))
7563                         }
7564                 } else {
7565                         for k2, v2 := range v {
7566                                 ee.EncodeUint(uint64(k2))
7567                                 ee.EncodeInt(int64(v2))
7568                         }
7569                 }
7570         }
7571         ee.WriteMapEnd()
7572 }
7573
7574 func (e *Encoder) fastpathEncMapUint16Int16R(f *codecFnInfo, rv reflect.Value) {
7575         fastpathTV.EncMapUint16Int16V(rv2i(rv).(map[uint16]int16), e)
7576 }
7577 func (_ fastpathT) EncMapUint16Int16V(v map[uint16]int16, e *Encoder) {
7578         if v == nil {
7579                 e.e.EncodeNil()
7580                 return
7581         }
7582         ee, esep := e.e, e.hh.hasElemSeparators()
7583         ee.WriteMapStart(len(v))
7584         if e.h.Canonical {
7585                 v2 := make([]uint64, len(v))
7586                 var i int
7587                 for k, _ := range v {
7588                         v2[i] = uint64(k)
7589                         i++
7590                 }
7591                 sort.Sort(uintSlice(v2))
7592                 if esep {
7593                         for _, k2 := range v2 {
7594                                 ee.WriteMapElemKey()
7595                                 ee.EncodeUint(uint64(uint16(k2)))
7596                                 ee.WriteMapElemValue()
7597                                 ee.EncodeInt(int64(v[uint16(k2)]))
7598                         }
7599                 } else {
7600                         for _, k2 := range v2 {
7601                                 ee.EncodeUint(uint64(uint16(k2)))
7602                                 ee.EncodeInt(int64(v[uint16(k2)]))
7603                         }
7604                 }
7605         } else {
7606                 if esep {
7607                         for k2, v2 := range v {
7608                                 ee.WriteMapElemKey()
7609                                 ee.EncodeUint(uint64(k2))
7610                                 ee.WriteMapElemValue()
7611                                 ee.EncodeInt(int64(v2))
7612                         }
7613                 } else {
7614                         for k2, v2 := range v {
7615                                 ee.EncodeUint(uint64(k2))
7616                                 ee.EncodeInt(int64(v2))
7617                         }
7618                 }
7619         }
7620         ee.WriteMapEnd()
7621 }
7622
7623 func (e *Encoder) fastpathEncMapUint16Int32R(f *codecFnInfo, rv reflect.Value) {
7624         fastpathTV.EncMapUint16Int32V(rv2i(rv).(map[uint16]int32), e)
7625 }
7626 func (_ fastpathT) EncMapUint16Int32V(v map[uint16]int32, e *Encoder) {
7627         if v == nil {
7628                 e.e.EncodeNil()
7629                 return
7630         }
7631         ee, esep := e.e, e.hh.hasElemSeparators()
7632         ee.WriteMapStart(len(v))
7633         if e.h.Canonical {
7634                 v2 := make([]uint64, len(v))
7635                 var i int
7636                 for k, _ := range v {
7637                         v2[i] = uint64(k)
7638                         i++
7639                 }
7640                 sort.Sort(uintSlice(v2))
7641                 if esep {
7642                         for _, k2 := range v2 {
7643                                 ee.WriteMapElemKey()
7644                                 ee.EncodeUint(uint64(uint16(k2)))
7645                                 ee.WriteMapElemValue()
7646                                 ee.EncodeInt(int64(v[uint16(k2)]))
7647                         }
7648                 } else {
7649                         for _, k2 := range v2 {
7650                                 ee.EncodeUint(uint64(uint16(k2)))
7651                                 ee.EncodeInt(int64(v[uint16(k2)]))
7652                         }
7653                 }
7654         } else {
7655                 if esep {
7656                         for k2, v2 := range v {
7657                                 ee.WriteMapElemKey()
7658                                 ee.EncodeUint(uint64(k2))
7659                                 ee.WriteMapElemValue()
7660                                 ee.EncodeInt(int64(v2))
7661                         }
7662                 } else {
7663                         for k2, v2 := range v {
7664                                 ee.EncodeUint(uint64(k2))
7665                                 ee.EncodeInt(int64(v2))
7666                         }
7667                 }
7668         }
7669         ee.WriteMapEnd()
7670 }
7671
7672 func (e *Encoder) fastpathEncMapUint16Int64R(f *codecFnInfo, rv reflect.Value) {
7673         fastpathTV.EncMapUint16Int64V(rv2i(rv).(map[uint16]int64), e)
7674 }
7675 func (_ fastpathT) EncMapUint16Int64V(v map[uint16]int64, e *Encoder) {
7676         if v == nil {
7677                 e.e.EncodeNil()
7678                 return
7679         }
7680         ee, esep := e.e, e.hh.hasElemSeparators()
7681         ee.WriteMapStart(len(v))
7682         if e.h.Canonical {
7683                 v2 := make([]uint64, len(v))
7684                 var i int
7685                 for k, _ := range v {
7686                         v2[i] = uint64(k)
7687                         i++
7688                 }
7689                 sort.Sort(uintSlice(v2))
7690                 if esep {
7691                         for _, k2 := range v2 {
7692                                 ee.WriteMapElemKey()
7693                                 ee.EncodeUint(uint64(uint16(k2)))
7694                                 ee.WriteMapElemValue()
7695                                 ee.EncodeInt(int64(v[uint16(k2)]))
7696                         }
7697                 } else {
7698                         for _, k2 := range v2 {
7699                                 ee.EncodeUint(uint64(uint16(k2)))
7700                                 ee.EncodeInt(int64(v[uint16(k2)]))
7701                         }
7702                 }
7703         } else {
7704                 if esep {
7705                         for k2, v2 := range v {
7706                                 ee.WriteMapElemKey()
7707                                 ee.EncodeUint(uint64(k2))
7708                                 ee.WriteMapElemValue()
7709                                 ee.EncodeInt(int64(v2))
7710                         }
7711                 } else {
7712                         for k2, v2 := range v {
7713                                 ee.EncodeUint(uint64(k2))
7714                                 ee.EncodeInt(int64(v2))
7715                         }
7716                 }
7717         }
7718         ee.WriteMapEnd()
7719 }
7720
7721 func (e *Encoder) fastpathEncMapUint16Float32R(f *codecFnInfo, rv reflect.Value) {
7722         fastpathTV.EncMapUint16Float32V(rv2i(rv).(map[uint16]float32), e)
7723 }
7724 func (_ fastpathT) EncMapUint16Float32V(v map[uint16]float32, e *Encoder) {
7725         if v == nil {
7726                 e.e.EncodeNil()
7727                 return
7728         }
7729         ee, esep := e.e, e.hh.hasElemSeparators()
7730         ee.WriteMapStart(len(v))
7731         if e.h.Canonical {
7732                 v2 := make([]uint64, len(v))
7733                 var i int
7734                 for k, _ := range v {
7735                         v2[i] = uint64(k)
7736                         i++
7737                 }
7738                 sort.Sort(uintSlice(v2))
7739                 if esep {
7740                         for _, k2 := range v2 {
7741                                 ee.WriteMapElemKey()
7742                                 ee.EncodeUint(uint64(uint16(k2)))
7743                                 ee.WriteMapElemValue()
7744                                 ee.EncodeFloat32(v[uint16(k2)])
7745                         }
7746                 } else {
7747                         for _, k2 := range v2 {
7748                                 ee.EncodeUint(uint64(uint16(k2)))
7749                                 ee.EncodeFloat32(v[uint16(k2)])
7750                         }
7751                 }
7752         } else {
7753                 if esep {
7754                         for k2, v2 := range v {
7755                                 ee.WriteMapElemKey()
7756                                 ee.EncodeUint(uint64(k2))
7757                                 ee.WriteMapElemValue()
7758                                 ee.EncodeFloat32(v2)
7759                         }
7760                 } else {
7761                         for k2, v2 := range v {
7762                                 ee.EncodeUint(uint64(k2))
7763                                 ee.EncodeFloat32(v2)
7764                         }
7765                 }
7766         }
7767         ee.WriteMapEnd()
7768 }
7769
7770 func (e *Encoder) fastpathEncMapUint16Float64R(f *codecFnInfo, rv reflect.Value) {
7771         fastpathTV.EncMapUint16Float64V(rv2i(rv).(map[uint16]float64), e)
7772 }
7773 func (_ fastpathT) EncMapUint16Float64V(v map[uint16]float64, e *Encoder) {
7774         if v == nil {
7775                 e.e.EncodeNil()
7776                 return
7777         }
7778         ee, esep := e.e, e.hh.hasElemSeparators()
7779         ee.WriteMapStart(len(v))
7780         if e.h.Canonical {
7781                 v2 := make([]uint64, len(v))
7782                 var i int
7783                 for k, _ := range v {
7784                         v2[i] = uint64(k)
7785                         i++
7786                 }
7787                 sort.Sort(uintSlice(v2))
7788                 if esep {
7789                         for _, k2 := range v2 {
7790                                 ee.WriteMapElemKey()
7791                                 ee.EncodeUint(uint64(uint16(k2)))
7792                                 ee.WriteMapElemValue()
7793                                 ee.EncodeFloat64(v[uint16(k2)])
7794                         }
7795                 } else {
7796                         for _, k2 := range v2 {
7797                                 ee.EncodeUint(uint64(uint16(k2)))
7798                                 ee.EncodeFloat64(v[uint16(k2)])
7799                         }
7800                 }
7801         } else {
7802                 if esep {
7803                         for k2, v2 := range v {
7804                                 ee.WriteMapElemKey()
7805                                 ee.EncodeUint(uint64(k2))
7806                                 ee.WriteMapElemValue()
7807                                 ee.EncodeFloat64(v2)
7808                         }
7809                 } else {
7810                         for k2, v2 := range v {
7811                                 ee.EncodeUint(uint64(k2))
7812                                 ee.EncodeFloat64(v2)
7813                         }
7814                 }
7815         }
7816         ee.WriteMapEnd()
7817 }
7818
7819 func (e *Encoder) fastpathEncMapUint16BoolR(f *codecFnInfo, rv reflect.Value) {
7820         fastpathTV.EncMapUint16BoolV(rv2i(rv).(map[uint16]bool), e)
7821 }
7822 func (_ fastpathT) EncMapUint16BoolV(v map[uint16]bool, e *Encoder) {
7823         if v == nil {
7824                 e.e.EncodeNil()
7825                 return
7826         }
7827         ee, esep := e.e, e.hh.hasElemSeparators()
7828         ee.WriteMapStart(len(v))
7829         if e.h.Canonical {
7830                 v2 := make([]uint64, len(v))
7831                 var i int
7832                 for k, _ := range v {
7833                         v2[i] = uint64(k)
7834                         i++
7835                 }
7836                 sort.Sort(uintSlice(v2))
7837                 if esep {
7838                         for _, k2 := range v2 {
7839                                 ee.WriteMapElemKey()
7840                                 ee.EncodeUint(uint64(uint16(k2)))
7841                                 ee.WriteMapElemValue()
7842                                 ee.EncodeBool(v[uint16(k2)])
7843                         }
7844                 } else {
7845                         for _, k2 := range v2 {
7846                                 ee.EncodeUint(uint64(uint16(k2)))
7847                                 ee.EncodeBool(v[uint16(k2)])
7848                         }
7849                 }
7850         } else {
7851                 if esep {
7852                         for k2, v2 := range v {
7853                                 ee.WriteMapElemKey()
7854                                 ee.EncodeUint(uint64(k2))
7855                                 ee.WriteMapElemValue()
7856                                 ee.EncodeBool(v2)
7857                         }
7858                 } else {
7859                         for k2, v2 := range v {
7860                                 ee.EncodeUint(uint64(k2))
7861                                 ee.EncodeBool(v2)
7862                         }
7863                 }
7864         }
7865         ee.WriteMapEnd()
7866 }
7867
7868 func (e *Encoder) fastpathEncMapUint32IntfR(f *codecFnInfo, rv reflect.Value) {
7869         fastpathTV.EncMapUint32IntfV(rv2i(rv).(map[uint32]interface{}), e)
7870 }
7871 func (_ fastpathT) EncMapUint32IntfV(v map[uint32]interface{}, e *Encoder) {
7872         if v == nil {
7873                 e.e.EncodeNil()
7874                 return
7875         }
7876         ee, esep := e.e, e.hh.hasElemSeparators()
7877         ee.WriteMapStart(len(v))
7878         if e.h.Canonical {
7879                 v2 := make([]uint64, len(v))
7880                 var i int
7881                 for k, _ := range v {
7882                         v2[i] = uint64(k)
7883                         i++
7884                 }
7885                 sort.Sort(uintSlice(v2))
7886                 if esep {
7887                         for _, k2 := range v2 {
7888                                 ee.WriteMapElemKey()
7889                                 ee.EncodeUint(uint64(uint32(k2)))
7890                                 ee.WriteMapElemValue()
7891                                 e.encode(v[uint32(k2)])
7892                         }
7893                 } else {
7894                         for _, k2 := range v2 {
7895                                 ee.EncodeUint(uint64(uint32(k2)))
7896                                 e.encode(v[uint32(k2)])
7897                         }
7898                 }
7899         } else {
7900                 if esep {
7901                         for k2, v2 := range v {
7902                                 ee.WriteMapElemKey()
7903                                 ee.EncodeUint(uint64(k2))
7904                                 ee.WriteMapElemValue()
7905                                 e.encode(v2)
7906                         }
7907                 } else {
7908                         for k2, v2 := range v {
7909                                 ee.EncodeUint(uint64(k2))
7910                                 e.encode(v2)
7911                         }
7912                 }
7913         }
7914         ee.WriteMapEnd()
7915 }
7916
7917 func (e *Encoder) fastpathEncMapUint32StringR(f *codecFnInfo, rv reflect.Value) {
7918         fastpathTV.EncMapUint32StringV(rv2i(rv).(map[uint32]string), e)
7919 }
7920 func (_ fastpathT) EncMapUint32StringV(v map[uint32]string, e *Encoder) {
7921         if v == nil {
7922                 e.e.EncodeNil()
7923                 return
7924         }
7925         ee, esep := e.e, e.hh.hasElemSeparators()
7926         ee.WriteMapStart(len(v))
7927         if e.h.Canonical {
7928                 v2 := make([]uint64, len(v))
7929                 var i int
7930                 for k, _ := range v {
7931                         v2[i] = uint64(k)
7932                         i++
7933                 }
7934                 sort.Sort(uintSlice(v2))
7935                 if esep {
7936                         for _, k2 := range v2 {
7937                                 ee.WriteMapElemKey()
7938                                 ee.EncodeUint(uint64(uint32(k2)))
7939                                 ee.WriteMapElemValue()
7940                                 ee.EncodeString(cUTF8, v[uint32(k2)])
7941                         }
7942                 } else {
7943                         for _, k2 := range v2 {
7944                                 ee.EncodeUint(uint64(uint32(k2)))
7945                                 ee.EncodeString(cUTF8, v[uint32(k2)])
7946                         }
7947                 }
7948         } else {
7949                 if esep {
7950                         for k2, v2 := range v {
7951                                 ee.WriteMapElemKey()
7952                                 ee.EncodeUint(uint64(k2))
7953                                 ee.WriteMapElemValue()
7954                                 ee.EncodeString(cUTF8, v2)
7955                         }
7956                 } else {
7957                         for k2, v2 := range v {
7958                                 ee.EncodeUint(uint64(k2))
7959                                 ee.EncodeString(cUTF8, v2)
7960                         }
7961                 }
7962         }
7963         ee.WriteMapEnd()
7964 }
7965
7966 func (e *Encoder) fastpathEncMapUint32UintR(f *codecFnInfo, rv reflect.Value) {
7967         fastpathTV.EncMapUint32UintV(rv2i(rv).(map[uint32]uint), e)
7968 }
7969 func (_ fastpathT) EncMapUint32UintV(v map[uint32]uint, e *Encoder) {
7970         if v == nil {
7971                 e.e.EncodeNil()
7972                 return
7973         }
7974         ee, esep := e.e, e.hh.hasElemSeparators()
7975         ee.WriteMapStart(len(v))
7976         if e.h.Canonical {
7977                 v2 := make([]uint64, len(v))
7978                 var i int
7979                 for k, _ := range v {
7980                         v2[i] = uint64(k)
7981                         i++
7982                 }
7983                 sort.Sort(uintSlice(v2))
7984                 if esep {
7985                         for _, k2 := range v2 {
7986                                 ee.WriteMapElemKey()
7987                                 ee.EncodeUint(uint64(uint32(k2)))
7988                                 ee.WriteMapElemValue()
7989                                 ee.EncodeUint(uint64(v[uint32(k2)]))
7990                         }
7991                 } else {
7992                         for _, k2 := range v2 {
7993                                 ee.EncodeUint(uint64(uint32(k2)))
7994                                 ee.EncodeUint(uint64(v[uint32(k2)]))
7995                         }
7996                 }
7997         } else {
7998                 if esep {
7999                         for k2, v2 := range v {
8000                                 ee.WriteMapElemKey()
8001                                 ee.EncodeUint(uint64(k2))
8002                                 ee.WriteMapElemValue()
8003                                 ee.EncodeUint(uint64(v2))
8004                         }
8005                 } else {
8006                         for k2, v2 := range v {
8007                                 ee.EncodeUint(uint64(k2))
8008                                 ee.EncodeUint(uint64(v2))
8009                         }
8010                 }
8011         }
8012         ee.WriteMapEnd()
8013 }
8014
8015 func (e *Encoder) fastpathEncMapUint32Uint8R(f *codecFnInfo, rv reflect.Value) {
8016         fastpathTV.EncMapUint32Uint8V(rv2i(rv).(map[uint32]uint8), e)
8017 }
8018 func (_ fastpathT) EncMapUint32Uint8V(v map[uint32]uint8, e *Encoder) {
8019         if v == nil {
8020                 e.e.EncodeNil()
8021                 return
8022         }
8023         ee, esep := e.e, e.hh.hasElemSeparators()
8024         ee.WriteMapStart(len(v))
8025         if e.h.Canonical {
8026                 v2 := make([]uint64, len(v))
8027                 var i int
8028                 for k, _ := range v {
8029                         v2[i] = uint64(k)
8030                         i++
8031                 }
8032                 sort.Sort(uintSlice(v2))
8033                 if esep {
8034                         for _, k2 := range v2 {
8035                                 ee.WriteMapElemKey()
8036                                 ee.EncodeUint(uint64(uint32(k2)))
8037                                 ee.WriteMapElemValue()
8038                                 ee.EncodeUint(uint64(v[uint32(k2)]))
8039                         }
8040                 } else {
8041                         for _, k2 := range v2 {
8042                                 ee.EncodeUint(uint64(uint32(k2)))
8043                                 ee.EncodeUint(uint64(v[uint32(k2)]))
8044                         }
8045                 }
8046         } else {
8047                 if esep {
8048                         for k2, v2 := range v {
8049                                 ee.WriteMapElemKey()
8050                                 ee.EncodeUint(uint64(k2))
8051                                 ee.WriteMapElemValue()
8052                                 ee.EncodeUint(uint64(v2))
8053                         }
8054                 } else {
8055                         for k2, v2 := range v {
8056                                 ee.EncodeUint(uint64(k2))
8057                                 ee.EncodeUint(uint64(v2))
8058                         }
8059                 }
8060         }
8061         ee.WriteMapEnd()
8062 }
8063
8064 func (e *Encoder) fastpathEncMapUint32Uint16R(f *codecFnInfo, rv reflect.Value) {
8065         fastpathTV.EncMapUint32Uint16V(rv2i(rv).(map[uint32]uint16), e)
8066 }
8067 func (_ fastpathT) EncMapUint32Uint16V(v map[uint32]uint16, e *Encoder) {
8068         if v == nil {
8069                 e.e.EncodeNil()
8070                 return
8071         }
8072         ee, esep := e.e, e.hh.hasElemSeparators()
8073         ee.WriteMapStart(len(v))
8074         if e.h.Canonical {
8075                 v2 := make([]uint64, len(v))
8076                 var i int
8077                 for k, _ := range v {
8078                         v2[i] = uint64(k)
8079                         i++
8080                 }
8081                 sort.Sort(uintSlice(v2))
8082                 if esep {
8083                         for _, k2 := range v2 {
8084                                 ee.WriteMapElemKey()
8085                                 ee.EncodeUint(uint64(uint32(k2)))
8086                                 ee.WriteMapElemValue()
8087                                 ee.EncodeUint(uint64(v[uint32(k2)]))
8088                         }
8089                 } else {
8090                         for _, k2 := range v2 {
8091                                 ee.EncodeUint(uint64(uint32(k2)))
8092                                 ee.EncodeUint(uint64(v[uint32(k2)]))
8093                         }
8094                 }
8095         } else {
8096                 if esep {
8097                         for k2, v2 := range v {
8098                                 ee.WriteMapElemKey()
8099                                 ee.EncodeUint(uint64(k2))
8100                                 ee.WriteMapElemValue()
8101                                 ee.EncodeUint(uint64(v2))
8102                         }
8103                 } else {
8104                         for k2, v2 := range v {
8105                                 ee.EncodeUint(uint64(k2))
8106                                 ee.EncodeUint(uint64(v2))
8107                         }
8108                 }
8109         }
8110         ee.WriteMapEnd()
8111 }
8112
8113 func (e *Encoder) fastpathEncMapUint32Uint32R(f *codecFnInfo, rv reflect.Value) {
8114         fastpathTV.EncMapUint32Uint32V(rv2i(rv).(map[uint32]uint32), e)
8115 }
8116 func (_ fastpathT) EncMapUint32Uint32V(v map[uint32]uint32, e *Encoder) {
8117         if v == nil {
8118                 e.e.EncodeNil()
8119                 return
8120         }
8121         ee, esep := e.e, e.hh.hasElemSeparators()
8122         ee.WriteMapStart(len(v))
8123         if e.h.Canonical {
8124                 v2 := make([]uint64, len(v))
8125                 var i int
8126                 for k, _ := range v {
8127                         v2[i] = uint64(k)
8128                         i++
8129                 }
8130                 sort.Sort(uintSlice(v2))
8131                 if esep {
8132                         for _, k2 := range v2 {
8133                                 ee.WriteMapElemKey()
8134                                 ee.EncodeUint(uint64(uint32(k2)))
8135                                 ee.WriteMapElemValue()
8136                                 ee.EncodeUint(uint64(v[uint32(k2)]))
8137                         }
8138                 } else {
8139                         for _, k2 := range v2 {
8140                                 ee.EncodeUint(uint64(uint32(k2)))
8141                                 ee.EncodeUint(uint64(v[uint32(k2)]))
8142                         }
8143                 }
8144         } else {
8145                 if esep {
8146                         for k2, v2 := range v {
8147                                 ee.WriteMapElemKey()
8148                                 ee.EncodeUint(uint64(k2))
8149                                 ee.WriteMapElemValue()
8150                                 ee.EncodeUint(uint64(v2))
8151                         }
8152                 } else {
8153                         for k2, v2 := range v {
8154                                 ee.EncodeUint(uint64(k2))
8155                                 ee.EncodeUint(uint64(v2))
8156                         }
8157                 }
8158         }
8159         ee.WriteMapEnd()
8160 }
8161
8162 func (e *Encoder) fastpathEncMapUint32Uint64R(f *codecFnInfo, rv reflect.Value) {
8163         fastpathTV.EncMapUint32Uint64V(rv2i(rv).(map[uint32]uint64), e)
8164 }
8165 func (_ fastpathT) EncMapUint32Uint64V(v map[uint32]uint64, e *Encoder) {
8166         if v == nil {
8167                 e.e.EncodeNil()
8168                 return
8169         }
8170         ee, esep := e.e, e.hh.hasElemSeparators()
8171         ee.WriteMapStart(len(v))
8172         if e.h.Canonical {
8173                 v2 := make([]uint64, len(v))
8174                 var i int
8175                 for k, _ := range v {
8176                         v2[i] = uint64(k)
8177                         i++
8178                 }
8179                 sort.Sort(uintSlice(v2))
8180                 if esep {
8181                         for _, k2 := range v2 {
8182                                 ee.WriteMapElemKey()
8183                                 ee.EncodeUint(uint64(uint32(k2)))
8184                                 ee.WriteMapElemValue()
8185                                 ee.EncodeUint(uint64(v[uint32(k2)]))
8186                         }
8187                 } else {
8188                         for _, k2 := range v2 {
8189                                 ee.EncodeUint(uint64(uint32(k2)))
8190                                 ee.EncodeUint(uint64(v[uint32(k2)]))
8191                         }
8192                 }
8193         } else {
8194                 if esep {
8195                         for k2, v2 := range v {
8196                                 ee.WriteMapElemKey()
8197                                 ee.EncodeUint(uint64(k2))
8198                                 ee.WriteMapElemValue()
8199                                 ee.EncodeUint(uint64(v2))
8200                         }
8201                 } else {
8202                         for k2, v2 := range v {
8203                                 ee.EncodeUint(uint64(k2))
8204                                 ee.EncodeUint(uint64(v2))
8205                         }
8206                 }
8207         }
8208         ee.WriteMapEnd()
8209 }
8210
8211 func (e *Encoder) fastpathEncMapUint32UintptrR(f *codecFnInfo, rv reflect.Value) {
8212         fastpathTV.EncMapUint32UintptrV(rv2i(rv).(map[uint32]uintptr), e)
8213 }
8214 func (_ fastpathT) EncMapUint32UintptrV(v map[uint32]uintptr, e *Encoder) {
8215         if v == nil {
8216                 e.e.EncodeNil()
8217                 return
8218         }
8219         ee, esep := e.e, e.hh.hasElemSeparators()
8220         ee.WriteMapStart(len(v))
8221         if e.h.Canonical {
8222                 v2 := make([]uint64, len(v))
8223                 var i int
8224                 for k, _ := range v {
8225                         v2[i] = uint64(k)
8226                         i++
8227                 }
8228                 sort.Sort(uintSlice(v2))
8229                 if esep {
8230                         for _, k2 := range v2 {
8231                                 ee.WriteMapElemKey()
8232                                 ee.EncodeUint(uint64(uint32(k2)))
8233                                 ee.WriteMapElemValue()
8234                                 e.encode(v[uint32(k2)])
8235                         }
8236                 } else {
8237                         for _, k2 := range v2 {
8238                                 ee.EncodeUint(uint64(uint32(k2)))
8239                                 e.encode(v[uint32(k2)])
8240                         }
8241                 }
8242         } else {
8243                 if esep {
8244                         for k2, v2 := range v {
8245                                 ee.WriteMapElemKey()
8246                                 ee.EncodeUint(uint64(k2))
8247                                 ee.WriteMapElemValue()
8248                                 e.encode(v2)
8249                         }
8250                 } else {
8251                         for k2, v2 := range v {
8252                                 ee.EncodeUint(uint64(k2))
8253                                 e.encode(v2)
8254                         }
8255                 }
8256         }
8257         ee.WriteMapEnd()
8258 }
8259
8260 func (e *Encoder) fastpathEncMapUint32IntR(f *codecFnInfo, rv reflect.Value) {
8261         fastpathTV.EncMapUint32IntV(rv2i(rv).(map[uint32]int), e)
8262 }
8263 func (_ fastpathT) EncMapUint32IntV(v map[uint32]int, e *Encoder) {
8264         if v == nil {
8265                 e.e.EncodeNil()
8266                 return
8267         }
8268         ee, esep := e.e, e.hh.hasElemSeparators()
8269         ee.WriteMapStart(len(v))
8270         if e.h.Canonical {
8271                 v2 := make([]uint64, len(v))
8272                 var i int
8273                 for k, _ := range v {
8274                         v2[i] = uint64(k)
8275                         i++
8276                 }
8277                 sort.Sort(uintSlice(v2))
8278                 if esep {
8279                         for _, k2 := range v2 {
8280                                 ee.WriteMapElemKey()
8281                                 ee.EncodeUint(uint64(uint32(k2)))
8282                                 ee.WriteMapElemValue()
8283                                 ee.EncodeInt(int64(v[uint32(k2)]))
8284                         }
8285                 } else {
8286                         for _, k2 := range v2 {
8287                                 ee.EncodeUint(uint64(uint32(k2)))
8288                                 ee.EncodeInt(int64(v[uint32(k2)]))
8289                         }
8290                 }
8291         } else {
8292                 if esep {
8293                         for k2, v2 := range v {
8294                                 ee.WriteMapElemKey()
8295                                 ee.EncodeUint(uint64(k2))
8296                                 ee.WriteMapElemValue()
8297                                 ee.EncodeInt(int64(v2))
8298                         }
8299                 } else {
8300                         for k2, v2 := range v {
8301                                 ee.EncodeUint(uint64(k2))
8302                                 ee.EncodeInt(int64(v2))
8303                         }
8304                 }
8305         }
8306         ee.WriteMapEnd()
8307 }
8308
8309 func (e *Encoder) fastpathEncMapUint32Int8R(f *codecFnInfo, rv reflect.Value) {
8310         fastpathTV.EncMapUint32Int8V(rv2i(rv).(map[uint32]int8), e)
8311 }
8312 func (_ fastpathT) EncMapUint32Int8V(v map[uint32]int8, e *Encoder) {
8313         if v == nil {
8314                 e.e.EncodeNil()
8315                 return
8316         }
8317         ee, esep := e.e, e.hh.hasElemSeparators()
8318         ee.WriteMapStart(len(v))
8319         if e.h.Canonical {
8320                 v2 := make([]uint64, len(v))
8321                 var i int
8322                 for k, _ := range v {
8323                         v2[i] = uint64(k)
8324                         i++
8325                 }
8326                 sort.Sort(uintSlice(v2))
8327                 if esep {
8328                         for _, k2 := range v2 {
8329                                 ee.WriteMapElemKey()
8330                                 ee.EncodeUint(uint64(uint32(k2)))
8331                                 ee.WriteMapElemValue()
8332                                 ee.EncodeInt(int64(v[uint32(k2)]))
8333                         }
8334                 } else {
8335                         for _, k2 := range v2 {
8336                                 ee.EncodeUint(uint64(uint32(k2)))
8337                                 ee.EncodeInt(int64(v[uint32(k2)]))
8338                         }
8339                 }
8340         } else {
8341                 if esep {
8342                         for k2, v2 := range v {
8343                                 ee.WriteMapElemKey()
8344                                 ee.EncodeUint(uint64(k2))
8345                                 ee.WriteMapElemValue()
8346                                 ee.EncodeInt(int64(v2))
8347                         }
8348                 } else {
8349                         for k2, v2 := range v {
8350                                 ee.EncodeUint(uint64(k2))
8351                                 ee.EncodeInt(int64(v2))
8352                         }
8353                 }
8354         }
8355         ee.WriteMapEnd()
8356 }
8357
8358 func (e *Encoder) fastpathEncMapUint32Int16R(f *codecFnInfo, rv reflect.Value) {
8359         fastpathTV.EncMapUint32Int16V(rv2i(rv).(map[uint32]int16), e)
8360 }
8361 func (_ fastpathT) EncMapUint32Int16V(v map[uint32]int16, e *Encoder) {
8362         if v == nil {
8363                 e.e.EncodeNil()
8364                 return
8365         }
8366         ee, esep := e.e, e.hh.hasElemSeparators()
8367         ee.WriteMapStart(len(v))
8368         if e.h.Canonical {
8369                 v2 := make([]uint64, len(v))
8370                 var i int
8371                 for k, _ := range v {
8372                         v2[i] = uint64(k)
8373                         i++
8374                 }
8375                 sort.Sort(uintSlice(v2))
8376                 if esep {
8377                         for _, k2 := range v2 {
8378                                 ee.WriteMapElemKey()
8379                                 ee.EncodeUint(uint64(uint32(k2)))
8380                                 ee.WriteMapElemValue()
8381                                 ee.EncodeInt(int64(v[uint32(k2)]))
8382                         }
8383                 } else {
8384                         for _, k2 := range v2 {
8385                                 ee.EncodeUint(uint64(uint32(k2)))
8386                                 ee.EncodeInt(int64(v[uint32(k2)]))
8387                         }
8388                 }
8389         } else {
8390                 if esep {
8391                         for k2, v2 := range v {
8392                                 ee.WriteMapElemKey()
8393                                 ee.EncodeUint(uint64(k2))
8394                                 ee.WriteMapElemValue()
8395                                 ee.EncodeInt(int64(v2))
8396                         }
8397                 } else {
8398                         for k2, v2 := range v {
8399                                 ee.EncodeUint(uint64(k2))
8400                                 ee.EncodeInt(int64(v2))
8401                         }
8402                 }
8403         }
8404         ee.WriteMapEnd()
8405 }
8406
8407 func (e *Encoder) fastpathEncMapUint32Int32R(f *codecFnInfo, rv reflect.Value) {
8408         fastpathTV.EncMapUint32Int32V(rv2i(rv).(map[uint32]int32), e)
8409 }
8410 func (_ fastpathT) EncMapUint32Int32V(v map[uint32]int32, e *Encoder) {
8411         if v == nil {
8412                 e.e.EncodeNil()
8413                 return
8414         }
8415         ee, esep := e.e, e.hh.hasElemSeparators()
8416         ee.WriteMapStart(len(v))
8417         if e.h.Canonical {
8418                 v2 := make([]uint64, len(v))
8419                 var i int
8420                 for k, _ := range v {
8421                         v2[i] = uint64(k)
8422                         i++
8423                 }
8424                 sort.Sort(uintSlice(v2))
8425                 if esep {
8426                         for _, k2 := range v2 {
8427                                 ee.WriteMapElemKey()
8428                                 ee.EncodeUint(uint64(uint32(k2)))
8429                                 ee.WriteMapElemValue()
8430                                 ee.EncodeInt(int64(v[uint32(k2)]))
8431                         }
8432                 } else {
8433                         for _, k2 := range v2 {
8434                                 ee.EncodeUint(uint64(uint32(k2)))
8435                                 ee.EncodeInt(int64(v[uint32(k2)]))
8436                         }
8437                 }
8438         } else {
8439                 if esep {
8440                         for k2, v2 := range v {
8441                                 ee.WriteMapElemKey()
8442                                 ee.EncodeUint(uint64(k2))
8443                                 ee.WriteMapElemValue()
8444                                 ee.EncodeInt(int64(v2))
8445                         }
8446                 } else {
8447                         for k2, v2 := range v {
8448                                 ee.EncodeUint(uint64(k2))
8449                                 ee.EncodeInt(int64(v2))
8450                         }
8451                 }
8452         }
8453         ee.WriteMapEnd()
8454 }
8455
8456 func (e *Encoder) fastpathEncMapUint32Int64R(f *codecFnInfo, rv reflect.Value) {
8457         fastpathTV.EncMapUint32Int64V(rv2i(rv).(map[uint32]int64), e)
8458 }
8459 func (_ fastpathT) EncMapUint32Int64V(v map[uint32]int64, e *Encoder) {
8460         if v == nil {
8461                 e.e.EncodeNil()
8462                 return
8463         }
8464         ee, esep := e.e, e.hh.hasElemSeparators()
8465         ee.WriteMapStart(len(v))
8466         if e.h.Canonical {
8467                 v2 := make([]uint64, len(v))
8468                 var i int
8469                 for k, _ := range v {
8470                         v2[i] = uint64(k)
8471                         i++
8472                 }
8473                 sort.Sort(uintSlice(v2))
8474                 if esep {
8475                         for _, k2 := range v2 {
8476                                 ee.WriteMapElemKey()
8477                                 ee.EncodeUint(uint64(uint32(k2)))
8478                                 ee.WriteMapElemValue()
8479                                 ee.EncodeInt(int64(v[uint32(k2)]))
8480                         }
8481                 } else {
8482                         for _, k2 := range v2 {
8483                                 ee.EncodeUint(uint64(uint32(k2)))
8484                                 ee.EncodeInt(int64(v[uint32(k2)]))
8485                         }
8486                 }
8487         } else {
8488                 if esep {
8489                         for k2, v2 := range v {
8490                                 ee.WriteMapElemKey()
8491                                 ee.EncodeUint(uint64(k2))
8492                                 ee.WriteMapElemValue()
8493                                 ee.EncodeInt(int64(v2))
8494                         }
8495                 } else {
8496                         for k2, v2 := range v {
8497                                 ee.EncodeUint(uint64(k2))
8498                                 ee.EncodeInt(int64(v2))
8499                         }
8500                 }
8501         }
8502         ee.WriteMapEnd()
8503 }
8504
8505 func (e *Encoder) fastpathEncMapUint32Float32R(f *codecFnInfo, rv reflect.Value) {
8506         fastpathTV.EncMapUint32Float32V(rv2i(rv).(map[uint32]float32), e)
8507 }
8508 func (_ fastpathT) EncMapUint32Float32V(v map[uint32]float32, e *Encoder) {
8509         if v == nil {
8510                 e.e.EncodeNil()
8511                 return
8512         }
8513         ee, esep := e.e, e.hh.hasElemSeparators()
8514         ee.WriteMapStart(len(v))
8515         if e.h.Canonical {
8516                 v2 := make([]uint64, len(v))
8517                 var i int
8518                 for k, _ := range v {
8519                         v2[i] = uint64(k)
8520                         i++
8521                 }
8522                 sort.Sort(uintSlice(v2))
8523                 if esep {
8524                         for _, k2 := range v2 {
8525                                 ee.WriteMapElemKey()
8526                                 ee.EncodeUint(uint64(uint32(k2)))
8527                                 ee.WriteMapElemValue()
8528                                 ee.EncodeFloat32(v[uint32(k2)])
8529                         }
8530                 } else {
8531                         for _, k2 := range v2 {
8532                                 ee.EncodeUint(uint64(uint32(k2)))
8533                                 ee.EncodeFloat32(v[uint32(k2)])
8534                         }
8535                 }
8536         } else {
8537                 if esep {
8538                         for k2, v2 := range v {
8539                                 ee.WriteMapElemKey()
8540                                 ee.EncodeUint(uint64(k2))
8541                                 ee.WriteMapElemValue()
8542                                 ee.EncodeFloat32(v2)
8543                         }
8544                 } else {
8545                         for k2, v2 := range v {
8546                                 ee.EncodeUint(uint64(k2))
8547                                 ee.EncodeFloat32(v2)
8548                         }
8549                 }
8550         }
8551         ee.WriteMapEnd()
8552 }
8553
8554 func (e *Encoder) fastpathEncMapUint32Float64R(f *codecFnInfo, rv reflect.Value) {
8555         fastpathTV.EncMapUint32Float64V(rv2i(rv).(map[uint32]float64), e)
8556 }
8557 func (_ fastpathT) EncMapUint32Float64V(v map[uint32]float64, e *Encoder) {
8558         if v == nil {
8559                 e.e.EncodeNil()
8560                 return
8561         }
8562         ee, esep := e.e, e.hh.hasElemSeparators()
8563         ee.WriteMapStart(len(v))
8564         if e.h.Canonical {
8565                 v2 := make([]uint64, len(v))
8566                 var i int
8567                 for k, _ := range v {
8568                         v2[i] = uint64(k)
8569                         i++
8570                 }
8571                 sort.Sort(uintSlice(v2))
8572                 if esep {
8573                         for _, k2 := range v2 {
8574                                 ee.WriteMapElemKey()
8575                                 ee.EncodeUint(uint64(uint32(k2)))
8576                                 ee.WriteMapElemValue()
8577                                 ee.EncodeFloat64(v[uint32(k2)])
8578                         }
8579                 } else {
8580                         for _, k2 := range v2 {
8581                                 ee.EncodeUint(uint64(uint32(k2)))
8582                                 ee.EncodeFloat64(v[uint32(k2)])
8583                         }
8584                 }
8585         } else {
8586                 if esep {
8587                         for k2, v2 := range v {
8588                                 ee.WriteMapElemKey()
8589                                 ee.EncodeUint(uint64(k2))
8590                                 ee.WriteMapElemValue()
8591                                 ee.EncodeFloat64(v2)
8592                         }
8593                 } else {
8594                         for k2, v2 := range v {
8595                                 ee.EncodeUint(uint64(k2))
8596                                 ee.EncodeFloat64(v2)
8597                         }
8598                 }
8599         }
8600         ee.WriteMapEnd()
8601 }
8602
8603 func (e *Encoder) fastpathEncMapUint32BoolR(f *codecFnInfo, rv reflect.Value) {
8604         fastpathTV.EncMapUint32BoolV(rv2i(rv).(map[uint32]bool), e)
8605 }
8606 func (_ fastpathT) EncMapUint32BoolV(v map[uint32]bool, e *Encoder) {
8607         if v == nil {
8608                 e.e.EncodeNil()
8609                 return
8610         }
8611         ee, esep := e.e, e.hh.hasElemSeparators()
8612         ee.WriteMapStart(len(v))
8613         if e.h.Canonical {
8614                 v2 := make([]uint64, len(v))
8615                 var i int
8616                 for k, _ := range v {
8617                         v2[i] = uint64(k)
8618                         i++
8619                 }
8620                 sort.Sort(uintSlice(v2))
8621                 if esep {
8622                         for _, k2 := range v2 {
8623                                 ee.WriteMapElemKey()
8624                                 ee.EncodeUint(uint64(uint32(k2)))
8625                                 ee.WriteMapElemValue()
8626                                 ee.EncodeBool(v[uint32(k2)])
8627                         }
8628                 } else {
8629                         for _, k2 := range v2 {
8630                                 ee.EncodeUint(uint64(uint32(k2)))
8631                                 ee.EncodeBool(v[uint32(k2)])
8632                         }
8633                 }
8634         } else {
8635                 if esep {
8636                         for k2, v2 := range v {
8637                                 ee.WriteMapElemKey()
8638                                 ee.EncodeUint(uint64(k2))
8639                                 ee.WriteMapElemValue()
8640                                 ee.EncodeBool(v2)
8641                         }
8642                 } else {
8643                         for k2, v2 := range v {
8644                                 ee.EncodeUint(uint64(k2))
8645                                 ee.EncodeBool(v2)
8646                         }
8647                 }
8648         }
8649         ee.WriteMapEnd()
8650 }
8651
8652 func (e *Encoder) fastpathEncMapUint64IntfR(f *codecFnInfo, rv reflect.Value) {
8653         fastpathTV.EncMapUint64IntfV(rv2i(rv).(map[uint64]interface{}), e)
8654 }
8655 func (_ fastpathT) EncMapUint64IntfV(v map[uint64]interface{}, e *Encoder) {
8656         if v == nil {
8657                 e.e.EncodeNil()
8658                 return
8659         }
8660         ee, esep := e.e, e.hh.hasElemSeparators()
8661         ee.WriteMapStart(len(v))
8662         if e.h.Canonical {
8663                 v2 := make([]uint64, len(v))
8664                 var i int
8665                 for k, _ := range v {
8666                         v2[i] = uint64(k)
8667                         i++
8668                 }
8669                 sort.Sort(uintSlice(v2))
8670                 if esep {
8671                         for _, k2 := range v2 {
8672                                 ee.WriteMapElemKey()
8673                                 ee.EncodeUint(uint64(uint64(k2)))
8674                                 ee.WriteMapElemValue()
8675                                 e.encode(v[uint64(k2)])
8676                         }
8677                 } else {
8678                         for _, k2 := range v2 {
8679                                 ee.EncodeUint(uint64(uint64(k2)))
8680                                 e.encode(v[uint64(k2)])
8681                         }
8682                 }
8683         } else {
8684                 if esep {
8685                         for k2, v2 := range v {
8686                                 ee.WriteMapElemKey()
8687                                 ee.EncodeUint(uint64(k2))
8688                                 ee.WriteMapElemValue()
8689                                 e.encode(v2)
8690                         }
8691                 } else {
8692                         for k2, v2 := range v {
8693                                 ee.EncodeUint(uint64(k2))
8694                                 e.encode(v2)
8695                         }
8696                 }
8697         }
8698         ee.WriteMapEnd()
8699 }
8700
8701 func (e *Encoder) fastpathEncMapUint64StringR(f *codecFnInfo, rv reflect.Value) {
8702         fastpathTV.EncMapUint64StringV(rv2i(rv).(map[uint64]string), e)
8703 }
8704 func (_ fastpathT) EncMapUint64StringV(v map[uint64]string, e *Encoder) {
8705         if v == nil {
8706                 e.e.EncodeNil()
8707                 return
8708         }
8709         ee, esep := e.e, e.hh.hasElemSeparators()
8710         ee.WriteMapStart(len(v))
8711         if e.h.Canonical {
8712                 v2 := make([]uint64, len(v))
8713                 var i int
8714                 for k, _ := range v {
8715                         v2[i] = uint64(k)
8716                         i++
8717                 }
8718                 sort.Sort(uintSlice(v2))
8719                 if esep {
8720                         for _, k2 := range v2 {
8721                                 ee.WriteMapElemKey()
8722                                 ee.EncodeUint(uint64(uint64(k2)))
8723                                 ee.WriteMapElemValue()
8724                                 ee.EncodeString(cUTF8, v[uint64(k2)])
8725                         }
8726                 } else {
8727                         for _, k2 := range v2 {
8728                                 ee.EncodeUint(uint64(uint64(k2)))
8729                                 ee.EncodeString(cUTF8, v[uint64(k2)])
8730                         }
8731                 }
8732         } else {
8733                 if esep {
8734                         for k2, v2 := range v {
8735                                 ee.WriteMapElemKey()
8736                                 ee.EncodeUint(uint64(k2))
8737                                 ee.WriteMapElemValue()
8738                                 ee.EncodeString(cUTF8, v2)
8739                         }
8740                 } else {
8741                         for k2, v2 := range v {
8742                                 ee.EncodeUint(uint64(k2))
8743                                 ee.EncodeString(cUTF8, v2)
8744                         }
8745                 }
8746         }
8747         ee.WriteMapEnd()
8748 }
8749
8750 func (e *Encoder) fastpathEncMapUint64UintR(f *codecFnInfo, rv reflect.Value) {
8751         fastpathTV.EncMapUint64UintV(rv2i(rv).(map[uint64]uint), e)
8752 }
8753 func (_ fastpathT) EncMapUint64UintV(v map[uint64]uint, e *Encoder) {
8754         if v == nil {
8755                 e.e.EncodeNil()
8756                 return
8757         }
8758         ee, esep := e.e, e.hh.hasElemSeparators()
8759         ee.WriteMapStart(len(v))
8760         if e.h.Canonical {
8761                 v2 := make([]uint64, len(v))
8762                 var i int
8763                 for k, _ := range v {
8764                         v2[i] = uint64(k)
8765                         i++
8766                 }
8767                 sort.Sort(uintSlice(v2))
8768                 if esep {
8769                         for _, k2 := range v2 {
8770                                 ee.WriteMapElemKey()
8771                                 ee.EncodeUint(uint64(uint64(k2)))
8772                                 ee.WriteMapElemValue()
8773                                 ee.EncodeUint(uint64(v[uint64(k2)]))
8774                         }
8775                 } else {
8776                         for _, k2 := range v2 {
8777                                 ee.EncodeUint(uint64(uint64(k2)))
8778                                 ee.EncodeUint(uint64(v[uint64(k2)]))
8779                         }
8780                 }
8781         } else {
8782                 if esep {
8783                         for k2, v2 := range v {
8784                                 ee.WriteMapElemKey()
8785                                 ee.EncodeUint(uint64(k2))
8786                                 ee.WriteMapElemValue()
8787                                 ee.EncodeUint(uint64(v2))
8788                         }
8789                 } else {
8790                         for k2, v2 := range v {
8791                                 ee.EncodeUint(uint64(k2))
8792                                 ee.EncodeUint(uint64(v2))
8793                         }
8794                 }
8795         }
8796         ee.WriteMapEnd()
8797 }
8798
8799 func (e *Encoder) fastpathEncMapUint64Uint8R(f *codecFnInfo, rv reflect.Value) {
8800         fastpathTV.EncMapUint64Uint8V(rv2i(rv).(map[uint64]uint8), e)
8801 }
8802 func (_ fastpathT) EncMapUint64Uint8V(v map[uint64]uint8, e *Encoder) {
8803         if v == nil {
8804                 e.e.EncodeNil()
8805                 return
8806         }
8807         ee, esep := e.e, e.hh.hasElemSeparators()
8808         ee.WriteMapStart(len(v))
8809         if e.h.Canonical {
8810                 v2 := make([]uint64, len(v))
8811                 var i int
8812                 for k, _ := range v {
8813                         v2[i] = uint64(k)
8814                         i++
8815                 }
8816                 sort.Sort(uintSlice(v2))
8817                 if esep {
8818                         for _, k2 := range v2 {
8819                                 ee.WriteMapElemKey()
8820                                 ee.EncodeUint(uint64(uint64(k2)))
8821                                 ee.WriteMapElemValue()
8822                                 ee.EncodeUint(uint64(v[uint64(k2)]))
8823                         }
8824                 } else {
8825                         for _, k2 := range v2 {
8826                                 ee.EncodeUint(uint64(uint64(k2)))
8827                                 ee.EncodeUint(uint64(v[uint64(k2)]))
8828                         }
8829                 }
8830         } else {
8831                 if esep {
8832                         for k2, v2 := range v {
8833                                 ee.WriteMapElemKey()
8834                                 ee.EncodeUint(uint64(k2))
8835                                 ee.WriteMapElemValue()
8836                                 ee.EncodeUint(uint64(v2))
8837                         }
8838                 } else {
8839                         for k2, v2 := range v {
8840                                 ee.EncodeUint(uint64(k2))
8841                                 ee.EncodeUint(uint64(v2))
8842                         }
8843                 }
8844         }
8845         ee.WriteMapEnd()
8846 }
8847
8848 func (e *Encoder) fastpathEncMapUint64Uint16R(f *codecFnInfo, rv reflect.Value) {
8849         fastpathTV.EncMapUint64Uint16V(rv2i(rv).(map[uint64]uint16), e)
8850 }
8851 func (_ fastpathT) EncMapUint64Uint16V(v map[uint64]uint16, e *Encoder) {
8852         if v == nil {
8853                 e.e.EncodeNil()
8854                 return
8855         }
8856         ee, esep := e.e, e.hh.hasElemSeparators()
8857         ee.WriteMapStart(len(v))
8858         if e.h.Canonical {
8859                 v2 := make([]uint64, len(v))
8860                 var i int
8861                 for k, _ := range v {
8862                         v2[i] = uint64(k)
8863                         i++
8864                 }
8865                 sort.Sort(uintSlice(v2))
8866                 if esep {
8867                         for _, k2 := range v2 {
8868                                 ee.WriteMapElemKey()
8869                                 ee.EncodeUint(uint64(uint64(k2)))
8870                                 ee.WriteMapElemValue()
8871                                 ee.EncodeUint(uint64(v[uint64(k2)]))
8872                         }
8873                 } else {
8874                         for _, k2 := range v2 {
8875                                 ee.EncodeUint(uint64(uint64(k2)))
8876                                 ee.EncodeUint(uint64(v[uint64(k2)]))
8877                         }
8878                 }
8879         } else {
8880                 if esep {
8881                         for k2, v2 := range v {
8882                                 ee.WriteMapElemKey()
8883                                 ee.EncodeUint(uint64(k2))
8884                                 ee.WriteMapElemValue()
8885                                 ee.EncodeUint(uint64(v2))
8886                         }
8887                 } else {
8888                         for k2, v2 := range v {
8889                                 ee.EncodeUint(uint64(k2))
8890                                 ee.EncodeUint(uint64(v2))
8891                         }
8892                 }
8893         }
8894         ee.WriteMapEnd()
8895 }
8896
8897 func (e *Encoder) fastpathEncMapUint64Uint32R(f *codecFnInfo, rv reflect.Value) {
8898         fastpathTV.EncMapUint64Uint32V(rv2i(rv).(map[uint64]uint32), e)
8899 }
8900 func (_ fastpathT) EncMapUint64Uint32V(v map[uint64]uint32, e *Encoder) {
8901         if v == nil {
8902                 e.e.EncodeNil()
8903                 return
8904         }
8905         ee, esep := e.e, e.hh.hasElemSeparators()
8906         ee.WriteMapStart(len(v))
8907         if e.h.Canonical {
8908                 v2 := make([]uint64, len(v))
8909                 var i int
8910                 for k, _ := range v {
8911                         v2[i] = uint64(k)
8912                         i++
8913                 }
8914                 sort.Sort(uintSlice(v2))
8915                 if esep {
8916                         for _, k2 := range v2 {
8917                                 ee.WriteMapElemKey()
8918                                 ee.EncodeUint(uint64(uint64(k2)))
8919                                 ee.WriteMapElemValue()
8920                                 ee.EncodeUint(uint64(v[uint64(k2)]))
8921                         }
8922                 } else {
8923                         for _, k2 := range v2 {
8924                                 ee.EncodeUint(uint64(uint64(k2)))
8925                                 ee.EncodeUint(uint64(v[uint64(k2)]))
8926                         }
8927                 }
8928         } else {
8929                 if esep {
8930                         for k2, v2 := range v {
8931                                 ee.WriteMapElemKey()
8932                                 ee.EncodeUint(uint64(k2))
8933                                 ee.WriteMapElemValue()
8934                                 ee.EncodeUint(uint64(v2))
8935                         }
8936                 } else {
8937                         for k2, v2 := range v {
8938                                 ee.EncodeUint(uint64(k2))
8939                                 ee.EncodeUint(uint64(v2))
8940                         }
8941                 }
8942         }
8943         ee.WriteMapEnd()
8944 }
8945
8946 func (e *Encoder) fastpathEncMapUint64Uint64R(f *codecFnInfo, rv reflect.Value) {
8947         fastpathTV.EncMapUint64Uint64V(rv2i(rv).(map[uint64]uint64), e)
8948 }
8949 func (_ fastpathT) EncMapUint64Uint64V(v map[uint64]uint64, e *Encoder) {
8950         if v == nil {
8951                 e.e.EncodeNil()
8952                 return
8953         }
8954         ee, esep := e.e, e.hh.hasElemSeparators()
8955         ee.WriteMapStart(len(v))
8956         if e.h.Canonical {
8957                 v2 := make([]uint64, len(v))
8958                 var i int
8959                 for k, _ := range v {
8960                         v2[i] = uint64(k)
8961                         i++
8962                 }
8963                 sort.Sort(uintSlice(v2))
8964                 if esep {
8965                         for _, k2 := range v2 {
8966                                 ee.WriteMapElemKey()
8967                                 ee.EncodeUint(uint64(uint64(k2)))
8968                                 ee.WriteMapElemValue()
8969                                 ee.EncodeUint(uint64(v[uint64(k2)]))
8970                         }
8971                 } else {
8972                         for _, k2 := range v2 {
8973                                 ee.EncodeUint(uint64(uint64(k2)))
8974                                 ee.EncodeUint(uint64(v[uint64(k2)]))
8975                         }
8976                 }
8977         } else {
8978                 if esep {
8979                         for k2, v2 := range v {
8980                                 ee.WriteMapElemKey()
8981                                 ee.EncodeUint(uint64(k2))
8982                                 ee.WriteMapElemValue()
8983                                 ee.EncodeUint(uint64(v2))
8984                         }
8985                 } else {
8986                         for k2, v2 := range v {
8987                                 ee.EncodeUint(uint64(k2))
8988                                 ee.EncodeUint(uint64(v2))
8989                         }
8990                 }
8991         }
8992         ee.WriteMapEnd()
8993 }
8994
8995 func (e *Encoder) fastpathEncMapUint64UintptrR(f *codecFnInfo, rv reflect.Value) {
8996         fastpathTV.EncMapUint64UintptrV(rv2i(rv).(map[uint64]uintptr), e)
8997 }
8998 func (_ fastpathT) EncMapUint64UintptrV(v map[uint64]uintptr, e *Encoder) {
8999         if v == nil {
9000                 e.e.EncodeNil()
9001                 return
9002         }
9003         ee, esep := e.e, e.hh.hasElemSeparators()
9004         ee.WriteMapStart(len(v))
9005         if e.h.Canonical {
9006                 v2 := make([]uint64, len(v))
9007                 var i int
9008                 for k, _ := range v {
9009                         v2[i] = uint64(k)
9010                         i++
9011                 }
9012                 sort.Sort(uintSlice(v2))
9013                 if esep {
9014                         for _, k2 := range v2 {
9015                                 ee.WriteMapElemKey()
9016                                 ee.EncodeUint(uint64(uint64(k2)))
9017                                 ee.WriteMapElemValue()
9018                                 e.encode(v[uint64(k2)])
9019                         }
9020                 } else {
9021                         for _, k2 := range v2 {
9022                                 ee.EncodeUint(uint64(uint64(k2)))
9023                                 e.encode(v[uint64(k2)])
9024                         }
9025                 }
9026         } else {
9027                 if esep {
9028                         for k2, v2 := range v {
9029                                 ee.WriteMapElemKey()
9030                                 ee.EncodeUint(uint64(k2))
9031                                 ee.WriteMapElemValue()
9032                                 e.encode(v2)
9033                         }
9034                 } else {
9035                         for k2, v2 := range v {
9036                                 ee.EncodeUint(uint64(k2))
9037                                 e.encode(v2)
9038                         }
9039                 }
9040         }
9041         ee.WriteMapEnd()
9042 }
9043
9044 func (e *Encoder) fastpathEncMapUint64IntR(f *codecFnInfo, rv reflect.Value) {
9045         fastpathTV.EncMapUint64IntV(rv2i(rv).(map[uint64]int), e)
9046 }
9047 func (_ fastpathT) EncMapUint64IntV(v map[uint64]int, e *Encoder) {
9048         if v == nil {
9049                 e.e.EncodeNil()
9050                 return
9051         }
9052         ee, esep := e.e, e.hh.hasElemSeparators()
9053         ee.WriteMapStart(len(v))
9054         if e.h.Canonical {
9055                 v2 := make([]uint64, len(v))
9056                 var i int
9057                 for k, _ := range v {
9058                         v2[i] = uint64(k)
9059                         i++
9060                 }
9061                 sort.Sort(uintSlice(v2))
9062                 if esep {
9063                         for _, k2 := range v2 {
9064                                 ee.WriteMapElemKey()
9065                                 ee.EncodeUint(uint64(uint64(k2)))
9066                                 ee.WriteMapElemValue()
9067                                 ee.EncodeInt(int64(v[uint64(k2)]))
9068                         }
9069                 } else {
9070                         for _, k2 := range v2 {
9071                                 ee.EncodeUint(uint64(uint64(k2)))
9072                                 ee.EncodeInt(int64(v[uint64(k2)]))
9073                         }
9074                 }
9075         } else {
9076                 if esep {
9077                         for k2, v2 := range v {
9078                                 ee.WriteMapElemKey()
9079                                 ee.EncodeUint(uint64(k2))
9080                                 ee.WriteMapElemValue()
9081                                 ee.EncodeInt(int64(v2))
9082                         }
9083                 } else {
9084                         for k2, v2 := range v {
9085                                 ee.EncodeUint(uint64(k2))
9086                                 ee.EncodeInt(int64(v2))
9087                         }
9088                 }
9089         }
9090         ee.WriteMapEnd()
9091 }
9092
9093 func (e *Encoder) fastpathEncMapUint64Int8R(f *codecFnInfo, rv reflect.Value) {
9094         fastpathTV.EncMapUint64Int8V(rv2i(rv).(map[uint64]int8), e)
9095 }
9096 func (_ fastpathT) EncMapUint64Int8V(v map[uint64]int8, e *Encoder) {
9097         if v == nil {
9098                 e.e.EncodeNil()
9099                 return
9100         }
9101         ee, esep := e.e, e.hh.hasElemSeparators()
9102         ee.WriteMapStart(len(v))
9103         if e.h.Canonical {
9104                 v2 := make([]uint64, len(v))
9105                 var i int
9106                 for k, _ := range v {
9107                         v2[i] = uint64(k)
9108                         i++
9109                 }
9110                 sort.Sort(uintSlice(v2))
9111                 if esep {
9112                         for _, k2 := range v2 {
9113                                 ee.WriteMapElemKey()
9114                                 ee.EncodeUint(uint64(uint64(k2)))
9115                                 ee.WriteMapElemValue()
9116                                 ee.EncodeInt(int64(v[uint64(k2)]))
9117                         }
9118                 } else {
9119                         for _, k2 := range v2 {
9120                                 ee.EncodeUint(uint64(uint64(k2)))
9121                                 ee.EncodeInt(int64(v[uint64(k2)]))
9122                         }
9123                 }
9124         } else {
9125                 if esep {
9126                         for k2, v2 := range v {
9127                                 ee.WriteMapElemKey()
9128                                 ee.EncodeUint(uint64(k2))
9129                                 ee.WriteMapElemValue()
9130                                 ee.EncodeInt(int64(v2))
9131                         }
9132                 } else {
9133                         for k2, v2 := range v {
9134                                 ee.EncodeUint(uint64(k2))
9135                                 ee.EncodeInt(int64(v2))
9136                         }
9137                 }
9138         }
9139         ee.WriteMapEnd()
9140 }
9141
9142 func (e *Encoder) fastpathEncMapUint64Int16R(f *codecFnInfo, rv reflect.Value) {
9143         fastpathTV.EncMapUint64Int16V(rv2i(rv).(map[uint64]int16), e)
9144 }
9145 func (_ fastpathT) EncMapUint64Int16V(v map[uint64]int16, e *Encoder) {
9146         if v == nil {
9147                 e.e.EncodeNil()
9148                 return
9149         }
9150         ee, esep := e.e, e.hh.hasElemSeparators()
9151         ee.WriteMapStart(len(v))
9152         if e.h.Canonical {
9153                 v2 := make([]uint64, len(v))
9154                 var i int
9155                 for k, _ := range v {
9156                         v2[i] = uint64(k)
9157                         i++
9158                 }
9159                 sort.Sort(uintSlice(v2))
9160                 if esep {
9161                         for _, k2 := range v2 {
9162                                 ee.WriteMapElemKey()
9163                                 ee.EncodeUint(uint64(uint64(k2)))
9164                                 ee.WriteMapElemValue()
9165                                 ee.EncodeInt(int64(v[uint64(k2)]))
9166                         }
9167                 } else {
9168                         for _, k2 := range v2 {
9169                                 ee.EncodeUint(uint64(uint64(k2)))
9170                                 ee.EncodeInt(int64(v[uint64(k2)]))
9171                         }
9172                 }
9173         } else {
9174                 if esep {
9175                         for k2, v2 := range v {
9176                                 ee.WriteMapElemKey()
9177                                 ee.EncodeUint(uint64(k2))
9178                                 ee.WriteMapElemValue()
9179                                 ee.EncodeInt(int64(v2))
9180                         }
9181                 } else {
9182                         for k2, v2 := range v {
9183                                 ee.EncodeUint(uint64(k2))
9184                                 ee.EncodeInt(int64(v2))
9185                         }
9186                 }
9187         }
9188         ee.WriteMapEnd()
9189 }
9190
9191 func (e *Encoder) fastpathEncMapUint64Int32R(f *codecFnInfo, rv reflect.Value) {
9192         fastpathTV.EncMapUint64Int32V(rv2i(rv).(map[uint64]int32), e)
9193 }
9194 func (_ fastpathT) EncMapUint64Int32V(v map[uint64]int32, e *Encoder) {
9195         if v == nil {
9196                 e.e.EncodeNil()
9197                 return
9198         }
9199         ee, esep := e.e, e.hh.hasElemSeparators()
9200         ee.WriteMapStart(len(v))
9201         if e.h.Canonical {
9202                 v2 := make([]uint64, len(v))
9203                 var i int
9204                 for k, _ := range v {
9205                         v2[i] = uint64(k)
9206                         i++
9207                 }
9208                 sort.Sort(uintSlice(v2))
9209                 if esep {
9210                         for _, k2 := range v2 {
9211                                 ee.WriteMapElemKey()
9212                                 ee.EncodeUint(uint64(uint64(k2)))
9213                                 ee.WriteMapElemValue()
9214                                 ee.EncodeInt(int64(v[uint64(k2)]))
9215                         }
9216                 } else {
9217                         for _, k2 := range v2 {
9218                                 ee.EncodeUint(uint64(uint64(k2)))
9219                                 ee.EncodeInt(int64(v[uint64(k2)]))
9220                         }
9221                 }
9222         } else {
9223                 if esep {
9224                         for k2, v2 := range v {
9225                                 ee.WriteMapElemKey()
9226                                 ee.EncodeUint(uint64(k2))
9227                                 ee.WriteMapElemValue()
9228                                 ee.EncodeInt(int64(v2))
9229                         }
9230                 } else {
9231                         for k2, v2 := range v {
9232                                 ee.EncodeUint(uint64(k2))
9233                                 ee.EncodeInt(int64(v2))
9234                         }
9235                 }
9236         }
9237         ee.WriteMapEnd()
9238 }
9239
9240 func (e *Encoder) fastpathEncMapUint64Int64R(f *codecFnInfo, rv reflect.Value) {
9241         fastpathTV.EncMapUint64Int64V(rv2i(rv).(map[uint64]int64), e)
9242 }
9243 func (_ fastpathT) EncMapUint64Int64V(v map[uint64]int64, e *Encoder) {
9244         if v == nil {
9245                 e.e.EncodeNil()
9246                 return
9247         }
9248         ee, esep := e.e, e.hh.hasElemSeparators()
9249         ee.WriteMapStart(len(v))
9250         if e.h.Canonical {
9251                 v2 := make([]uint64, len(v))
9252                 var i int
9253                 for k, _ := range v {
9254                         v2[i] = uint64(k)
9255                         i++
9256                 }
9257                 sort.Sort(uintSlice(v2))
9258                 if esep {
9259                         for _, k2 := range v2 {
9260                                 ee.WriteMapElemKey()
9261                                 ee.EncodeUint(uint64(uint64(k2)))
9262                                 ee.WriteMapElemValue()
9263                                 ee.EncodeInt(int64(v[uint64(k2)]))
9264                         }
9265                 } else {
9266                         for _, k2 := range v2 {
9267                                 ee.EncodeUint(uint64(uint64(k2)))
9268                                 ee.EncodeInt(int64(v[uint64(k2)]))
9269                         }
9270                 }
9271         } else {
9272                 if esep {
9273                         for k2, v2 := range v {
9274                                 ee.WriteMapElemKey()
9275                                 ee.EncodeUint(uint64(k2))
9276                                 ee.WriteMapElemValue()
9277                                 ee.EncodeInt(int64(v2))
9278                         }
9279                 } else {
9280                         for k2, v2 := range v {
9281                                 ee.EncodeUint(uint64(k2))
9282                                 ee.EncodeInt(int64(v2))
9283                         }
9284                 }
9285         }
9286         ee.WriteMapEnd()
9287 }
9288
9289 func (e *Encoder) fastpathEncMapUint64Float32R(f *codecFnInfo, rv reflect.Value) {
9290         fastpathTV.EncMapUint64Float32V(rv2i(rv).(map[uint64]float32), e)
9291 }
9292 func (_ fastpathT) EncMapUint64Float32V(v map[uint64]float32, e *Encoder) {
9293         if v == nil {
9294                 e.e.EncodeNil()
9295                 return
9296         }
9297         ee, esep := e.e, e.hh.hasElemSeparators()
9298         ee.WriteMapStart(len(v))
9299         if e.h.Canonical {
9300                 v2 := make([]uint64, len(v))
9301                 var i int
9302                 for k, _ := range v {
9303                         v2[i] = uint64(k)
9304                         i++
9305                 }
9306                 sort.Sort(uintSlice(v2))
9307                 if esep {
9308                         for _, k2 := range v2 {
9309                                 ee.WriteMapElemKey()
9310                                 ee.EncodeUint(uint64(uint64(k2)))
9311                                 ee.WriteMapElemValue()
9312                                 ee.EncodeFloat32(v[uint64(k2)])
9313                         }
9314                 } else {
9315                         for _, k2 := range v2 {
9316                                 ee.EncodeUint(uint64(uint64(k2)))
9317                                 ee.EncodeFloat32(v[uint64(k2)])
9318                         }
9319                 }
9320         } else {
9321                 if esep {
9322                         for k2, v2 := range v {
9323                                 ee.WriteMapElemKey()
9324                                 ee.EncodeUint(uint64(k2))
9325                                 ee.WriteMapElemValue()
9326                                 ee.EncodeFloat32(v2)
9327                         }
9328                 } else {
9329                         for k2, v2 := range v {
9330                                 ee.EncodeUint(uint64(k2))
9331                                 ee.EncodeFloat32(v2)
9332                         }
9333                 }
9334         }
9335         ee.WriteMapEnd()
9336 }
9337
9338 func (e *Encoder) fastpathEncMapUint64Float64R(f *codecFnInfo, rv reflect.Value) {
9339         fastpathTV.EncMapUint64Float64V(rv2i(rv).(map[uint64]float64), e)
9340 }
9341 func (_ fastpathT) EncMapUint64Float64V(v map[uint64]float64, e *Encoder) {
9342         if v == nil {
9343                 e.e.EncodeNil()
9344                 return
9345         }
9346         ee, esep := e.e, e.hh.hasElemSeparators()
9347         ee.WriteMapStart(len(v))
9348         if e.h.Canonical {
9349                 v2 := make([]uint64, len(v))
9350                 var i int
9351                 for k, _ := range v {
9352                         v2[i] = uint64(k)
9353                         i++
9354                 }
9355                 sort.Sort(uintSlice(v2))
9356                 if esep {
9357                         for _, k2 := range v2 {
9358                                 ee.WriteMapElemKey()
9359                                 ee.EncodeUint(uint64(uint64(k2)))
9360                                 ee.WriteMapElemValue()
9361                                 ee.EncodeFloat64(v[uint64(k2)])
9362                         }
9363                 } else {
9364                         for _, k2 := range v2 {
9365                                 ee.EncodeUint(uint64(uint64(k2)))
9366                                 ee.EncodeFloat64(v[uint64(k2)])
9367                         }
9368                 }
9369         } else {
9370                 if esep {
9371                         for k2, v2 := range v {
9372                                 ee.WriteMapElemKey()
9373                                 ee.EncodeUint(uint64(k2))
9374                                 ee.WriteMapElemValue()
9375                                 ee.EncodeFloat64(v2)
9376                         }
9377                 } else {
9378                         for k2, v2 := range v {
9379                                 ee.EncodeUint(uint64(k2))
9380                                 ee.EncodeFloat64(v2)
9381                         }
9382                 }
9383         }
9384         ee.WriteMapEnd()
9385 }
9386
9387 func (e *Encoder) fastpathEncMapUint64BoolR(f *codecFnInfo, rv reflect.Value) {
9388         fastpathTV.EncMapUint64BoolV(rv2i(rv).(map[uint64]bool), e)
9389 }
9390 func (_ fastpathT) EncMapUint64BoolV(v map[uint64]bool, e *Encoder) {
9391         if v == nil {
9392                 e.e.EncodeNil()
9393                 return
9394         }
9395         ee, esep := e.e, e.hh.hasElemSeparators()
9396         ee.WriteMapStart(len(v))
9397         if e.h.Canonical {
9398                 v2 := make([]uint64, len(v))
9399                 var i int
9400                 for k, _ := range v {
9401                         v2[i] = uint64(k)
9402                         i++
9403                 }
9404                 sort.Sort(uintSlice(v2))
9405                 if esep {
9406                         for _, k2 := range v2 {
9407                                 ee.WriteMapElemKey()
9408                                 ee.EncodeUint(uint64(uint64(k2)))
9409                                 ee.WriteMapElemValue()
9410                                 ee.EncodeBool(v[uint64(k2)])
9411                         }
9412                 } else {
9413                         for _, k2 := range v2 {
9414                                 ee.EncodeUint(uint64(uint64(k2)))
9415                                 ee.EncodeBool(v[uint64(k2)])
9416                         }
9417                 }
9418         } else {
9419                 if esep {
9420                         for k2, v2 := range v {
9421                                 ee.WriteMapElemKey()
9422                                 ee.EncodeUint(uint64(k2))
9423                                 ee.WriteMapElemValue()
9424                                 ee.EncodeBool(v2)
9425                         }
9426                 } else {
9427                         for k2, v2 := range v {
9428                                 ee.EncodeUint(uint64(k2))
9429                                 ee.EncodeBool(v2)
9430                         }
9431                 }
9432         }
9433         ee.WriteMapEnd()
9434 }
9435
9436 func (e *Encoder) fastpathEncMapUintptrIntfR(f *codecFnInfo, rv reflect.Value) {
9437         fastpathTV.EncMapUintptrIntfV(rv2i(rv).(map[uintptr]interface{}), e)
9438 }
9439 func (_ fastpathT) EncMapUintptrIntfV(v map[uintptr]interface{}, e *Encoder) {
9440         if v == nil {
9441                 e.e.EncodeNil()
9442                 return
9443         }
9444         ee, esep := e.e, e.hh.hasElemSeparators()
9445         ee.WriteMapStart(len(v))
9446         if e.h.Canonical {
9447                 v2 := make([]uint64, len(v))
9448                 var i int
9449                 for k, _ := range v {
9450                         v2[i] = uint64(k)
9451                         i++
9452                 }
9453                 sort.Sort(uintSlice(v2))
9454                 if esep {
9455                         for _, k2 := range v2 {
9456                                 ee.WriteMapElemKey()
9457                                 e.encode(uintptr(k2))
9458                                 ee.WriteMapElemValue()
9459                                 e.encode(v[uintptr(k2)])
9460                         }
9461                 } else {
9462                         for _, k2 := range v2 {
9463                                 e.encode(uintptr(k2))
9464                                 e.encode(v[uintptr(k2)])
9465                         }
9466                 }
9467         } else {
9468                 if esep {
9469                         for k2, v2 := range v {
9470                                 ee.WriteMapElemKey()
9471                                 e.encode(k2)
9472                                 ee.WriteMapElemValue()
9473                                 e.encode(v2)
9474                         }
9475                 } else {
9476                         for k2, v2 := range v {
9477                                 e.encode(k2)
9478                                 e.encode(v2)
9479                         }
9480                 }
9481         }
9482         ee.WriteMapEnd()
9483 }
9484
9485 func (e *Encoder) fastpathEncMapUintptrStringR(f *codecFnInfo, rv reflect.Value) {
9486         fastpathTV.EncMapUintptrStringV(rv2i(rv).(map[uintptr]string), e)
9487 }
9488 func (_ fastpathT) EncMapUintptrStringV(v map[uintptr]string, e *Encoder) {
9489         if v == nil {
9490                 e.e.EncodeNil()
9491                 return
9492         }
9493         ee, esep := e.e, e.hh.hasElemSeparators()
9494         ee.WriteMapStart(len(v))
9495         if e.h.Canonical {
9496                 v2 := make([]uint64, len(v))
9497                 var i int
9498                 for k, _ := range v {
9499                         v2[i] = uint64(k)
9500                         i++
9501                 }
9502                 sort.Sort(uintSlice(v2))
9503                 if esep {
9504                         for _, k2 := range v2 {
9505                                 ee.WriteMapElemKey()
9506                                 e.encode(uintptr(k2))
9507                                 ee.WriteMapElemValue()
9508                                 ee.EncodeString(cUTF8, v[uintptr(k2)])
9509                         }
9510                 } else {
9511                         for _, k2 := range v2 {
9512                                 e.encode(uintptr(k2))
9513                                 ee.EncodeString(cUTF8, v[uintptr(k2)])
9514                         }
9515                 }
9516         } else {
9517                 if esep {
9518                         for k2, v2 := range v {
9519                                 ee.WriteMapElemKey()
9520                                 e.encode(k2)
9521                                 ee.WriteMapElemValue()
9522                                 ee.EncodeString(cUTF8, v2)
9523                         }
9524                 } else {
9525                         for k2, v2 := range v {
9526                                 e.encode(k2)
9527                                 ee.EncodeString(cUTF8, v2)
9528                         }
9529                 }
9530         }
9531         ee.WriteMapEnd()
9532 }
9533
9534 func (e *Encoder) fastpathEncMapUintptrUintR(f *codecFnInfo, rv reflect.Value) {
9535         fastpathTV.EncMapUintptrUintV(rv2i(rv).(map[uintptr]uint), e)
9536 }
9537 func (_ fastpathT) EncMapUintptrUintV(v map[uintptr]uint, e *Encoder) {
9538         if v == nil {
9539                 e.e.EncodeNil()
9540                 return
9541         }
9542         ee, esep := e.e, e.hh.hasElemSeparators()
9543         ee.WriteMapStart(len(v))
9544         if e.h.Canonical {
9545                 v2 := make([]uint64, len(v))
9546                 var i int
9547                 for k, _ := range v {
9548                         v2[i] = uint64(k)
9549                         i++
9550                 }
9551                 sort.Sort(uintSlice(v2))
9552                 if esep {
9553                         for _, k2 := range v2 {
9554                                 ee.WriteMapElemKey()
9555                                 e.encode(uintptr(k2))
9556                                 ee.WriteMapElemValue()
9557                                 ee.EncodeUint(uint64(v[uintptr(k2)]))
9558                         }
9559                 } else {
9560                         for _, k2 := range v2 {
9561                                 e.encode(uintptr(k2))
9562                                 ee.EncodeUint(uint64(v[uintptr(k2)]))
9563                         }
9564                 }
9565         } else {
9566                 if esep {
9567                         for k2, v2 := range v {
9568                                 ee.WriteMapElemKey()
9569                                 e.encode(k2)
9570                                 ee.WriteMapElemValue()
9571                                 ee.EncodeUint(uint64(v2))
9572                         }
9573                 } else {
9574                         for k2, v2 := range v {
9575                                 e.encode(k2)
9576                                 ee.EncodeUint(uint64(v2))
9577                         }
9578                 }
9579         }
9580         ee.WriteMapEnd()
9581 }
9582
9583 func (e *Encoder) fastpathEncMapUintptrUint8R(f *codecFnInfo, rv reflect.Value) {
9584         fastpathTV.EncMapUintptrUint8V(rv2i(rv).(map[uintptr]uint8), e)
9585 }
9586 func (_ fastpathT) EncMapUintptrUint8V(v map[uintptr]uint8, e *Encoder) {
9587         if v == nil {
9588                 e.e.EncodeNil()
9589                 return
9590         }
9591         ee, esep := e.e, e.hh.hasElemSeparators()
9592         ee.WriteMapStart(len(v))
9593         if e.h.Canonical {
9594                 v2 := make([]uint64, len(v))
9595                 var i int
9596                 for k, _ := range v {
9597                         v2[i] = uint64(k)
9598                         i++
9599                 }
9600                 sort.Sort(uintSlice(v2))
9601                 if esep {
9602                         for _, k2 := range v2 {
9603                                 ee.WriteMapElemKey()
9604                                 e.encode(uintptr(k2))
9605                                 ee.WriteMapElemValue()
9606                                 ee.EncodeUint(uint64(v[uintptr(k2)]))
9607                         }
9608                 } else {
9609                         for _, k2 := range v2 {
9610                                 e.encode(uintptr(k2))
9611                                 ee.EncodeUint(uint64(v[uintptr(k2)]))
9612                         }
9613                 }
9614         } else {
9615                 if esep {
9616                         for k2, v2 := range v {
9617                                 ee.WriteMapElemKey()
9618                                 e.encode(k2)
9619                                 ee.WriteMapElemValue()
9620                                 ee.EncodeUint(uint64(v2))
9621                         }
9622                 } else {
9623                         for k2, v2 := range v {
9624                                 e.encode(k2)
9625                                 ee.EncodeUint(uint64(v2))
9626                         }
9627                 }
9628         }
9629         ee.WriteMapEnd()
9630 }
9631
9632 func (e *Encoder) fastpathEncMapUintptrUint16R(f *codecFnInfo, rv reflect.Value) {
9633         fastpathTV.EncMapUintptrUint16V(rv2i(rv).(map[uintptr]uint16), e)
9634 }
9635 func (_ fastpathT) EncMapUintptrUint16V(v map[uintptr]uint16, e *Encoder) {
9636         if v == nil {
9637                 e.e.EncodeNil()
9638                 return
9639         }
9640         ee, esep := e.e, e.hh.hasElemSeparators()
9641         ee.WriteMapStart(len(v))
9642         if e.h.Canonical {
9643                 v2 := make([]uint64, len(v))
9644                 var i int
9645                 for k, _ := range v {
9646                         v2[i] = uint64(k)
9647                         i++
9648                 }
9649                 sort.Sort(uintSlice(v2))
9650                 if esep {
9651                         for _, k2 := range v2 {
9652                                 ee.WriteMapElemKey()
9653                                 e.encode(uintptr(k2))
9654                                 ee.WriteMapElemValue()
9655                                 ee.EncodeUint(uint64(v[uintptr(k2)]))
9656                         }
9657                 } else {
9658                         for _, k2 := range v2 {
9659                                 e.encode(uintptr(k2))
9660                                 ee.EncodeUint(uint64(v[uintptr(k2)]))
9661                         }
9662                 }
9663         } else {
9664                 if esep {
9665                         for k2, v2 := range v {
9666                                 ee.WriteMapElemKey()
9667                                 e.encode(k2)
9668                                 ee.WriteMapElemValue()
9669                                 ee.EncodeUint(uint64(v2))
9670                         }
9671                 } else {
9672                         for k2, v2 := range v {
9673                                 e.encode(k2)
9674                                 ee.EncodeUint(uint64(v2))
9675                         }
9676                 }
9677         }
9678         ee.WriteMapEnd()
9679 }
9680
9681 func (e *Encoder) fastpathEncMapUintptrUint32R(f *codecFnInfo, rv reflect.Value) {
9682         fastpathTV.EncMapUintptrUint32V(rv2i(rv).(map[uintptr]uint32), e)
9683 }
9684 func (_ fastpathT) EncMapUintptrUint32V(v map[uintptr]uint32, e *Encoder) {
9685         if v == nil {
9686                 e.e.EncodeNil()
9687                 return
9688         }
9689         ee, esep := e.e, e.hh.hasElemSeparators()
9690         ee.WriteMapStart(len(v))
9691         if e.h.Canonical {
9692                 v2 := make([]uint64, len(v))
9693                 var i int
9694                 for k, _ := range v {
9695                         v2[i] = uint64(k)
9696                         i++
9697                 }
9698                 sort.Sort(uintSlice(v2))
9699                 if esep {
9700                         for _, k2 := range v2 {
9701                                 ee.WriteMapElemKey()
9702                                 e.encode(uintptr(k2))
9703                                 ee.WriteMapElemValue()
9704                                 ee.EncodeUint(uint64(v[uintptr(k2)]))
9705                         }
9706                 } else {
9707                         for _, k2 := range v2 {
9708                                 e.encode(uintptr(k2))
9709                                 ee.EncodeUint(uint64(v[uintptr(k2)]))
9710                         }
9711                 }
9712         } else {
9713                 if esep {
9714                         for k2, v2 := range v {
9715                                 ee.WriteMapElemKey()
9716                                 e.encode(k2)
9717                                 ee.WriteMapElemValue()
9718                                 ee.EncodeUint(uint64(v2))
9719                         }
9720                 } else {
9721                         for k2, v2 := range v {
9722                                 e.encode(k2)
9723                                 ee.EncodeUint(uint64(v2))
9724                         }
9725                 }
9726         }
9727         ee.WriteMapEnd()
9728 }
9729
9730 func (e *Encoder) fastpathEncMapUintptrUint64R(f *codecFnInfo, rv reflect.Value) {
9731         fastpathTV.EncMapUintptrUint64V(rv2i(rv).(map[uintptr]uint64), e)
9732 }
9733 func (_ fastpathT) EncMapUintptrUint64V(v map[uintptr]uint64, e *Encoder) {
9734         if v == nil {
9735                 e.e.EncodeNil()
9736                 return
9737         }
9738         ee, esep := e.e, e.hh.hasElemSeparators()
9739         ee.WriteMapStart(len(v))
9740         if e.h.Canonical {
9741                 v2 := make([]uint64, len(v))
9742                 var i int
9743                 for k, _ := range v {
9744                         v2[i] = uint64(k)
9745                         i++
9746                 }
9747                 sort.Sort(uintSlice(v2))
9748                 if esep {
9749                         for _, k2 := range v2 {
9750                                 ee.WriteMapElemKey()
9751                                 e.encode(uintptr(k2))
9752                                 ee.WriteMapElemValue()
9753                                 ee.EncodeUint(uint64(v[uintptr(k2)]))
9754                         }
9755                 } else {
9756                         for _, k2 := range v2 {
9757                                 e.encode(uintptr(k2))
9758                                 ee.EncodeUint(uint64(v[uintptr(k2)]))
9759                         }
9760                 }
9761         } else {
9762                 if esep {
9763                         for k2, v2 := range v {
9764                                 ee.WriteMapElemKey()
9765                                 e.encode(k2)
9766                                 ee.WriteMapElemValue()
9767                                 ee.EncodeUint(uint64(v2))
9768                         }
9769                 } else {
9770                         for k2, v2 := range v {
9771                                 e.encode(k2)
9772                                 ee.EncodeUint(uint64(v2))
9773                         }
9774                 }
9775         }
9776         ee.WriteMapEnd()
9777 }
9778
9779 func (e *Encoder) fastpathEncMapUintptrUintptrR(f *codecFnInfo, rv reflect.Value) {
9780         fastpathTV.EncMapUintptrUintptrV(rv2i(rv).(map[uintptr]uintptr), e)
9781 }
9782 func (_ fastpathT) EncMapUintptrUintptrV(v map[uintptr]uintptr, e *Encoder) {
9783         if v == nil {
9784                 e.e.EncodeNil()
9785                 return
9786         }
9787         ee, esep := e.e, e.hh.hasElemSeparators()
9788         ee.WriteMapStart(len(v))
9789         if e.h.Canonical {
9790                 v2 := make([]uint64, len(v))
9791                 var i int
9792                 for k, _ := range v {
9793                         v2[i] = uint64(k)
9794                         i++
9795                 }
9796                 sort.Sort(uintSlice(v2))
9797                 if esep {
9798                         for _, k2 := range v2 {
9799                                 ee.WriteMapElemKey()
9800                                 e.encode(uintptr(k2))
9801                                 ee.WriteMapElemValue()
9802                                 e.encode(v[uintptr(k2)])
9803                         }
9804                 } else {
9805                         for _, k2 := range v2 {
9806                                 e.encode(uintptr(k2))
9807                                 e.encode(v[uintptr(k2)])
9808                         }
9809                 }
9810         } else {
9811                 if esep {
9812                         for k2, v2 := range v {
9813                                 ee.WriteMapElemKey()
9814                                 e.encode(k2)
9815                                 ee.WriteMapElemValue()
9816                                 e.encode(v2)
9817                         }
9818                 } else {
9819                         for k2, v2 := range v {
9820                                 e.encode(k2)
9821                                 e.encode(v2)
9822                         }
9823                 }
9824         }
9825         ee.WriteMapEnd()
9826 }
9827
9828 func (e *Encoder) fastpathEncMapUintptrIntR(f *codecFnInfo, rv reflect.Value) {
9829         fastpathTV.EncMapUintptrIntV(rv2i(rv).(map[uintptr]int), e)
9830 }
9831 func (_ fastpathT) EncMapUintptrIntV(v map[uintptr]int, e *Encoder) {
9832         if v == nil {
9833                 e.e.EncodeNil()
9834                 return
9835         }
9836         ee, esep := e.e, e.hh.hasElemSeparators()
9837         ee.WriteMapStart(len(v))
9838         if e.h.Canonical {
9839                 v2 := make([]uint64, len(v))
9840                 var i int
9841                 for k, _ := range v {
9842                         v2[i] = uint64(k)
9843                         i++
9844                 }
9845                 sort.Sort(uintSlice(v2))
9846                 if esep {
9847                         for _, k2 := range v2 {
9848                                 ee.WriteMapElemKey()
9849                                 e.encode(uintptr(k2))
9850                                 ee.WriteMapElemValue()
9851                                 ee.EncodeInt(int64(v[uintptr(k2)]))
9852                         }
9853                 } else {
9854                         for _, k2 := range v2 {
9855                                 e.encode(uintptr(k2))
9856                                 ee.EncodeInt(int64(v[uintptr(k2)]))
9857                         }
9858                 }
9859         } else {
9860                 if esep {
9861                         for k2, v2 := range v {
9862                                 ee.WriteMapElemKey()
9863                                 e.encode(k2)
9864                                 ee.WriteMapElemValue()
9865                                 ee.EncodeInt(int64(v2))
9866                         }
9867                 } else {
9868                         for k2, v2 := range v {
9869                                 e.encode(k2)
9870                                 ee.EncodeInt(int64(v2))
9871                         }
9872                 }
9873         }
9874         ee.WriteMapEnd()
9875 }
9876
9877 func (e *Encoder) fastpathEncMapUintptrInt8R(f *codecFnInfo, rv reflect.Value) {
9878         fastpathTV.EncMapUintptrInt8V(rv2i(rv).(map[uintptr]int8), e)
9879 }
9880 func (_ fastpathT) EncMapUintptrInt8V(v map[uintptr]int8, e *Encoder) {
9881         if v == nil {
9882                 e.e.EncodeNil()
9883                 return
9884         }
9885         ee, esep := e.e, e.hh.hasElemSeparators()
9886         ee.WriteMapStart(len(v))
9887         if e.h.Canonical {
9888                 v2 := make([]uint64, len(v))
9889                 var i int
9890                 for k, _ := range v {
9891                         v2[i] = uint64(k)
9892                         i++
9893                 }
9894                 sort.Sort(uintSlice(v2))
9895                 if esep {
9896                         for _, k2 := range v2 {
9897                                 ee.WriteMapElemKey()
9898                                 e.encode(uintptr(k2))
9899                                 ee.WriteMapElemValue()
9900                                 ee.EncodeInt(int64(v[uintptr(k2)]))
9901                         }
9902                 } else {
9903                         for _, k2 := range v2 {
9904                                 e.encode(uintptr(k2))
9905                                 ee.EncodeInt(int64(v[uintptr(k2)]))
9906                         }
9907                 }
9908         } else {
9909                 if esep {
9910                         for k2, v2 := range v {
9911                                 ee.WriteMapElemKey()
9912                                 e.encode(k2)
9913                                 ee.WriteMapElemValue()
9914                                 ee.EncodeInt(int64(v2))
9915                         }
9916                 } else {
9917                         for k2, v2 := range v {
9918                                 e.encode(k2)
9919                                 ee.EncodeInt(int64(v2))
9920                         }
9921                 }
9922         }
9923         ee.WriteMapEnd()
9924 }
9925
9926 func (e *Encoder) fastpathEncMapUintptrInt16R(f *codecFnInfo, rv reflect.Value) {
9927         fastpathTV.EncMapUintptrInt16V(rv2i(rv).(map[uintptr]int16), e)
9928 }
9929 func (_ fastpathT) EncMapUintptrInt16V(v map[uintptr]int16, e *Encoder) {
9930         if v == nil {
9931                 e.e.EncodeNil()
9932                 return
9933         }
9934         ee, esep := e.e, e.hh.hasElemSeparators()
9935         ee.WriteMapStart(len(v))
9936         if e.h.Canonical {
9937                 v2 := make([]uint64, len(v))
9938                 var i int
9939                 for k, _ := range v {
9940                         v2[i] = uint64(k)
9941                         i++
9942                 }
9943                 sort.Sort(uintSlice(v2))
9944                 if esep {
9945                         for _, k2 := range v2 {
9946                                 ee.WriteMapElemKey()
9947                                 e.encode(uintptr(k2))
9948                                 ee.WriteMapElemValue()
9949                                 ee.EncodeInt(int64(v[uintptr(k2)]))
9950                         }
9951                 } else {
9952                         for _, k2 := range v2 {
9953                                 e.encode(uintptr(k2))
9954                                 ee.EncodeInt(int64(v[uintptr(k2)]))
9955                         }
9956                 }
9957         } else {
9958                 if esep {
9959                         for k2, v2 := range v {
9960                                 ee.WriteMapElemKey()
9961                                 e.encode(k2)
9962                                 ee.WriteMapElemValue()
9963                                 ee.EncodeInt(int64(v2))
9964                         }
9965                 } else {
9966                         for k2, v2 := range v {
9967                                 e.encode(k2)
9968                                 ee.EncodeInt(int64(v2))
9969                         }
9970                 }
9971         }
9972         ee.WriteMapEnd()
9973 }
9974
9975 func (e *Encoder) fastpathEncMapUintptrInt32R(f *codecFnInfo, rv reflect.Value) {
9976         fastpathTV.EncMapUintptrInt32V(rv2i(rv).(map[uintptr]int32), e)
9977 }
9978 func (_ fastpathT) EncMapUintptrInt32V(v map[uintptr]int32, e *Encoder) {
9979         if v == nil {
9980                 e.e.EncodeNil()
9981                 return
9982         }
9983         ee, esep := e.e, e.hh.hasElemSeparators()
9984         ee.WriteMapStart(len(v))
9985         if e.h.Canonical {
9986                 v2 := make([]uint64, len(v))
9987                 var i int
9988                 for k, _ := range v {
9989                         v2[i] = uint64(k)
9990                         i++
9991                 }
9992                 sort.Sort(uintSlice(v2))
9993                 if esep {
9994                         for _, k2 := range v2 {
9995                                 ee.WriteMapElemKey()
9996                                 e.encode(uintptr(k2))
9997                                 ee.WriteMapElemValue()
9998                                 ee.EncodeInt(int64(v[uintptr(k2)]))
9999                         }
10000                 } else {
10001                         for _, k2 := range v2 {
10002                                 e.encode(uintptr(k2))
10003                                 ee.EncodeInt(int64(v[uintptr(k2)]))
10004                         }
10005                 }
10006         } else {
10007                 if esep {
10008                         for k2, v2 := range v {
10009                                 ee.WriteMapElemKey()
10010                                 e.encode(k2)
10011                                 ee.WriteMapElemValue()
10012                                 ee.EncodeInt(int64(v2))
10013                         }
10014                 } else {
10015                         for k2, v2 := range v {
10016                                 e.encode(k2)
10017                                 ee.EncodeInt(int64(v2))
10018                         }
10019                 }
10020         }
10021         ee.WriteMapEnd()
10022 }
10023
10024 func (e *Encoder) fastpathEncMapUintptrInt64R(f *codecFnInfo, rv reflect.Value) {
10025         fastpathTV.EncMapUintptrInt64V(rv2i(rv).(map[uintptr]int64), e)
10026 }
10027 func (_ fastpathT) EncMapUintptrInt64V(v map[uintptr]int64, e *Encoder) {
10028         if v == nil {
10029                 e.e.EncodeNil()
10030                 return
10031         }
10032         ee, esep := e.e, e.hh.hasElemSeparators()
10033         ee.WriteMapStart(len(v))
10034         if e.h.Canonical {
10035                 v2 := make([]uint64, len(v))
10036                 var i int
10037                 for k, _ := range v {
10038                         v2[i] = uint64(k)
10039                         i++
10040                 }
10041                 sort.Sort(uintSlice(v2))
10042                 if esep {
10043                         for _, k2 := range v2 {
10044                                 ee.WriteMapElemKey()
10045                                 e.encode(uintptr(k2))
10046                                 ee.WriteMapElemValue()
10047                                 ee.EncodeInt(int64(v[uintptr(k2)]))
10048                         }
10049                 } else {
10050                         for _, k2 := range v2 {
10051                                 e.encode(uintptr(k2))
10052                                 ee.EncodeInt(int64(v[uintptr(k2)]))
10053                         }
10054                 }
10055         } else {
10056                 if esep {
10057                         for k2, v2 := range v {
10058                                 ee.WriteMapElemKey()
10059                                 e.encode(k2)
10060                                 ee.WriteMapElemValue()
10061                                 ee.EncodeInt(int64(v2))
10062                         }
10063                 } else {
10064                         for k2, v2 := range v {
10065                                 e.encode(k2)
10066                                 ee.EncodeInt(int64(v2))
10067                         }
10068                 }
10069         }
10070         ee.WriteMapEnd()
10071 }
10072
10073 func (e *Encoder) fastpathEncMapUintptrFloat32R(f *codecFnInfo, rv reflect.Value) {
10074         fastpathTV.EncMapUintptrFloat32V(rv2i(rv).(map[uintptr]float32), e)
10075 }
10076 func (_ fastpathT) EncMapUintptrFloat32V(v map[uintptr]float32, e *Encoder) {
10077         if v == nil {
10078                 e.e.EncodeNil()
10079                 return
10080         }
10081         ee, esep := e.e, e.hh.hasElemSeparators()
10082         ee.WriteMapStart(len(v))
10083         if e.h.Canonical {
10084                 v2 := make([]uint64, len(v))
10085                 var i int
10086                 for k, _ := range v {
10087                         v2[i] = uint64(k)
10088                         i++
10089                 }
10090                 sort.Sort(uintSlice(v2))
10091                 if esep {
10092                         for _, k2 := range v2 {
10093                                 ee.WriteMapElemKey()
10094                                 e.encode(uintptr(k2))
10095                                 ee.WriteMapElemValue()
10096                                 ee.EncodeFloat32(v[uintptr(k2)])
10097                         }
10098                 } else {
10099                         for _, k2 := range v2 {
10100                                 e.encode(uintptr(k2))
10101                                 ee.EncodeFloat32(v[uintptr(k2)])
10102                         }
10103                 }
10104         } else {
10105                 if esep {
10106                         for k2, v2 := range v {
10107                                 ee.WriteMapElemKey()
10108                                 e.encode(k2)
10109                                 ee.WriteMapElemValue()
10110                                 ee.EncodeFloat32(v2)
10111                         }
10112                 } else {
10113                         for k2, v2 := range v {
10114                                 e.encode(k2)
10115                                 ee.EncodeFloat32(v2)
10116                         }
10117                 }
10118         }
10119         ee.WriteMapEnd()
10120 }
10121
10122 func (e *Encoder) fastpathEncMapUintptrFloat64R(f *codecFnInfo, rv reflect.Value) {
10123         fastpathTV.EncMapUintptrFloat64V(rv2i(rv).(map[uintptr]float64), e)
10124 }
10125 func (_ fastpathT) EncMapUintptrFloat64V(v map[uintptr]float64, e *Encoder) {
10126         if v == nil {
10127                 e.e.EncodeNil()
10128                 return
10129         }
10130         ee, esep := e.e, e.hh.hasElemSeparators()
10131         ee.WriteMapStart(len(v))
10132         if e.h.Canonical {
10133                 v2 := make([]uint64, len(v))
10134                 var i int
10135                 for k, _ := range v {
10136                         v2[i] = uint64(k)
10137                         i++
10138                 }
10139                 sort.Sort(uintSlice(v2))
10140                 if esep {
10141                         for _, k2 := range v2 {
10142                                 ee.WriteMapElemKey()
10143                                 e.encode(uintptr(k2))
10144                                 ee.WriteMapElemValue()
10145                                 ee.EncodeFloat64(v[uintptr(k2)])
10146                         }
10147                 } else {
10148                         for _, k2 := range v2 {
10149                                 e.encode(uintptr(k2))
10150                                 ee.EncodeFloat64(v[uintptr(k2)])
10151                         }
10152                 }
10153         } else {
10154                 if esep {
10155                         for k2, v2 := range v {
10156                                 ee.WriteMapElemKey()
10157                                 e.encode(k2)
10158                                 ee.WriteMapElemValue()
10159                                 ee.EncodeFloat64(v2)
10160                         }
10161                 } else {
10162                         for k2, v2 := range v {
10163                                 e.encode(k2)
10164                                 ee.EncodeFloat64(v2)
10165                         }
10166                 }
10167         }
10168         ee.WriteMapEnd()
10169 }
10170
10171 func (e *Encoder) fastpathEncMapUintptrBoolR(f *codecFnInfo, rv reflect.Value) {
10172         fastpathTV.EncMapUintptrBoolV(rv2i(rv).(map[uintptr]bool), e)
10173 }
10174 func (_ fastpathT) EncMapUintptrBoolV(v map[uintptr]bool, e *Encoder) {
10175         if v == nil {
10176                 e.e.EncodeNil()
10177                 return
10178         }
10179         ee, esep := e.e, e.hh.hasElemSeparators()
10180         ee.WriteMapStart(len(v))
10181         if e.h.Canonical {
10182                 v2 := make([]uint64, len(v))
10183                 var i int
10184                 for k, _ := range v {
10185                         v2[i] = uint64(k)
10186                         i++
10187                 }
10188                 sort.Sort(uintSlice(v2))
10189                 if esep {
10190                         for _, k2 := range v2 {
10191                                 ee.WriteMapElemKey()
10192                                 e.encode(uintptr(k2))
10193                                 ee.WriteMapElemValue()
10194                                 ee.EncodeBool(v[uintptr(k2)])
10195                         }
10196                 } else {
10197                         for _, k2 := range v2 {
10198                                 e.encode(uintptr(k2))
10199                                 ee.EncodeBool(v[uintptr(k2)])
10200                         }
10201                 }
10202         } else {
10203                 if esep {
10204                         for k2, v2 := range v {
10205                                 ee.WriteMapElemKey()
10206                                 e.encode(k2)
10207                                 ee.WriteMapElemValue()
10208                                 ee.EncodeBool(v2)
10209                         }
10210                 } else {
10211                         for k2, v2 := range v {
10212                                 e.encode(k2)
10213                                 ee.EncodeBool(v2)
10214                         }
10215                 }
10216         }
10217         ee.WriteMapEnd()
10218 }
10219
10220 func (e *Encoder) fastpathEncMapIntIntfR(f *codecFnInfo, rv reflect.Value) {
10221         fastpathTV.EncMapIntIntfV(rv2i(rv).(map[int]interface{}), e)
10222 }
10223 func (_ fastpathT) EncMapIntIntfV(v map[int]interface{}, e *Encoder) {
10224         if v == nil {
10225                 e.e.EncodeNil()
10226                 return
10227         }
10228         ee, esep := e.e, e.hh.hasElemSeparators()
10229         ee.WriteMapStart(len(v))
10230         if e.h.Canonical {
10231                 v2 := make([]int64, len(v))
10232                 var i int
10233                 for k, _ := range v {
10234                         v2[i] = int64(k)
10235                         i++
10236                 }
10237                 sort.Sort(intSlice(v2))
10238                 if esep {
10239                         for _, k2 := range v2 {
10240                                 ee.WriteMapElemKey()
10241                                 ee.EncodeInt(int64(int(k2)))
10242                                 ee.WriteMapElemValue()
10243                                 e.encode(v[int(k2)])
10244                         }
10245                 } else {
10246                         for _, k2 := range v2 {
10247                                 ee.EncodeInt(int64(int(k2)))
10248                                 e.encode(v[int(k2)])
10249                         }
10250                 }
10251         } else {
10252                 if esep {
10253                         for k2, v2 := range v {
10254                                 ee.WriteMapElemKey()
10255                                 ee.EncodeInt(int64(k2))
10256                                 ee.WriteMapElemValue()
10257                                 e.encode(v2)
10258                         }
10259                 } else {
10260                         for k2, v2 := range v {
10261                                 ee.EncodeInt(int64(k2))
10262                                 e.encode(v2)
10263                         }
10264                 }
10265         }
10266         ee.WriteMapEnd()
10267 }
10268
10269 func (e *Encoder) fastpathEncMapIntStringR(f *codecFnInfo, rv reflect.Value) {
10270         fastpathTV.EncMapIntStringV(rv2i(rv).(map[int]string), e)
10271 }
10272 func (_ fastpathT) EncMapIntStringV(v map[int]string, e *Encoder) {
10273         if v == nil {
10274                 e.e.EncodeNil()
10275                 return
10276         }
10277         ee, esep := e.e, e.hh.hasElemSeparators()
10278         ee.WriteMapStart(len(v))
10279         if e.h.Canonical {
10280                 v2 := make([]int64, len(v))
10281                 var i int
10282                 for k, _ := range v {
10283                         v2[i] = int64(k)
10284                         i++
10285                 }
10286                 sort.Sort(intSlice(v2))
10287                 if esep {
10288                         for _, k2 := range v2 {
10289                                 ee.WriteMapElemKey()
10290                                 ee.EncodeInt(int64(int(k2)))
10291                                 ee.WriteMapElemValue()
10292                                 ee.EncodeString(cUTF8, v[int(k2)])
10293                         }
10294                 } else {
10295                         for _, k2 := range v2 {
10296                                 ee.EncodeInt(int64(int(k2)))
10297                                 ee.EncodeString(cUTF8, v[int(k2)])
10298                         }
10299                 }
10300         } else {
10301                 if esep {
10302                         for k2, v2 := range v {
10303                                 ee.WriteMapElemKey()
10304                                 ee.EncodeInt(int64(k2))
10305                                 ee.WriteMapElemValue()
10306                                 ee.EncodeString(cUTF8, v2)
10307                         }
10308                 } else {
10309                         for k2, v2 := range v {
10310                                 ee.EncodeInt(int64(k2))
10311                                 ee.EncodeString(cUTF8, v2)
10312                         }
10313                 }
10314         }
10315         ee.WriteMapEnd()
10316 }
10317
10318 func (e *Encoder) fastpathEncMapIntUintR(f *codecFnInfo, rv reflect.Value) {
10319         fastpathTV.EncMapIntUintV(rv2i(rv).(map[int]uint), e)
10320 }
10321 func (_ fastpathT) EncMapIntUintV(v map[int]uint, e *Encoder) {
10322         if v == nil {
10323                 e.e.EncodeNil()
10324                 return
10325         }
10326         ee, esep := e.e, e.hh.hasElemSeparators()
10327         ee.WriteMapStart(len(v))
10328         if e.h.Canonical {
10329                 v2 := make([]int64, len(v))
10330                 var i int
10331                 for k, _ := range v {
10332                         v2[i] = int64(k)
10333                         i++
10334                 }
10335                 sort.Sort(intSlice(v2))
10336                 if esep {
10337                         for _, k2 := range v2 {
10338                                 ee.WriteMapElemKey()
10339                                 ee.EncodeInt(int64(int(k2)))
10340                                 ee.WriteMapElemValue()
10341                                 ee.EncodeUint(uint64(v[int(k2)]))
10342                         }
10343                 } else {
10344                         for _, k2 := range v2 {
10345                                 ee.EncodeInt(int64(int(k2)))
10346                                 ee.EncodeUint(uint64(v[int(k2)]))
10347                         }
10348                 }
10349         } else {
10350                 if esep {
10351                         for k2, v2 := range v {
10352                                 ee.WriteMapElemKey()
10353                                 ee.EncodeInt(int64(k2))
10354                                 ee.WriteMapElemValue()
10355                                 ee.EncodeUint(uint64(v2))
10356                         }
10357                 } else {
10358                         for k2, v2 := range v {
10359                                 ee.EncodeInt(int64(k2))
10360                                 ee.EncodeUint(uint64(v2))
10361                         }
10362                 }
10363         }
10364         ee.WriteMapEnd()
10365 }
10366
10367 func (e *Encoder) fastpathEncMapIntUint8R(f *codecFnInfo, rv reflect.Value) {
10368         fastpathTV.EncMapIntUint8V(rv2i(rv).(map[int]uint8), e)
10369 }
10370 func (_ fastpathT) EncMapIntUint8V(v map[int]uint8, e *Encoder) {
10371         if v == nil {
10372                 e.e.EncodeNil()
10373                 return
10374         }
10375         ee, esep := e.e, e.hh.hasElemSeparators()
10376         ee.WriteMapStart(len(v))
10377         if e.h.Canonical {
10378                 v2 := make([]int64, len(v))
10379                 var i int
10380                 for k, _ := range v {
10381                         v2[i] = int64(k)
10382                         i++
10383                 }
10384                 sort.Sort(intSlice(v2))
10385                 if esep {
10386                         for _, k2 := range v2 {
10387                                 ee.WriteMapElemKey()
10388                                 ee.EncodeInt(int64(int(k2)))
10389                                 ee.WriteMapElemValue()
10390                                 ee.EncodeUint(uint64(v[int(k2)]))
10391                         }
10392                 } else {
10393                         for _, k2 := range v2 {
10394                                 ee.EncodeInt(int64(int(k2)))
10395                                 ee.EncodeUint(uint64(v[int(k2)]))
10396                         }
10397                 }
10398         } else {
10399                 if esep {
10400                         for k2, v2 := range v {
10401                                 ee.WriteMapElemKey()
10402                                 ee.EncodeInt(int64(k2))
10403                                 ee.WriteMapElemValue()
10404                                 ee.EncodeUint(uint64(v2))
10405                         }
10406                 } else {
10407                         for k2, v2 := range v {
10408                                 ee.EncodeInt(int64(k2))
10409                                 ee.EncodeUint(uint64(v2))
10410                         }
10411                 }
10412         }
10413         ee.WriteMapEnd()
10414 }
10415
10416 func (e *Encoder) fastpathEncMapIntUint16R(f *codecFnInfo, rv reflect.Value) {
10417         fastpathTV.EncMapIntUint16V(rv2i(rv).(map[int]uint16), e)
10418 }
10419 func (_ fastpathT) EncMapIntUint16V(v map[int]uint16, e *Encoder) {
10420         if v == nil {
10421                 e.e.EncodeNil()
10422                 return
10423         }
10424         ee, esep := e.e, e.hh.hasElemSeparators()
10425         ee.WriteMapStart(len(v))
10426         if e.h.Canonical {
10427                 v2 := make([]int64, len(v))
10428                 var i int
10429                 for k, _ := range v {
10430                         v2[i] = int64(k)
10431                         i++
10432                 }
10433                 sort.Sort(intSlice(v2))
10434                 if esep {
10435                         for _, k2 := range v2 {
10436                                 ee.WriteMapElemKey()
10437                                 ee.EncodeInt(int64(int(k2)))
10438                                 ee.WriteMapElemValue()
10439                                 ee.EncodeUint(uint64(v[int(k2)]))
10440                         }
10441                 } else {
10442                         for _, k2 := range v2 {
10443                                 ee.EncodeInt(int64(int(k2)))
10444                                 ee.EncodeUint(uint64(v[int(k2)]))
10445                         }
10446                 }
10447         } else {
10448                 if esep {
10449                         for k2, v2 := range v {
10450                                 ee.WriteMapElemKey()
10451                                 ee.EncodeInt(int64(k2))
10452                                 ee.WriteMapElemValue()
10453                                 ee.EncodeUint(uint64(v2))
10454                         }
10455                 } else {
10456                         for k2, v2 := range v {
10457                                 ee.EncodeInt(int64(k2))
10458                                 ee.EncodeUint(uint64(v2))
10459                         }
10460                 }
10461         }
10462         ee.WriteMapEnd()
10463 }
10464
10465 func (e *Encoder) fastpathEncMapIntUint32R(f *codecFnInfo, rv reflect.Value) {
10466         fastpathTV.EncMapIntUint32V(rv2i(rv).(map[int]uint32), e)
10467 }
10468 func (_ fastpathT) EncMapIntUint32V(v map[int]uint32, e *Encoder) {
10469         if v == nil {
10470                 e.e.EncodeNil()
10471                 return
10472         }
10473         ee, esep := e.e, e.hh.hasElemSeparators()
10474         ee.WriteMapStart(len(v))
10475         if e.h.Canonical {
10476                 v2 := make([]int64, len(v))
10477                 var i int
10478                 for k, _ := range v {
10479                         v2[i] = int64(k)
10480                         i++
10481                 }
10482                 sort.Sort(intSlice(v2))
10483                 if esep {
10484                         for _, k2 := range v2 {
10485                                 ee.WriteMapElemKey()
10486                                 ee.EncodeInt(int64(int(k2)))
10487                                 ee.WriteMapElemValue()
10488                                 ee.EncodeUint(uint64(v[int(k2)]))
10489                         }
10490                 } else {
10491                         for _, k2 := range v2 {
10492                                 ee.EncodeInt(int64(int(k2)))
10493                                 ee.EncodeUint(uint64(v[int(k2)]))
10494                         }
10495                 }
10496         } else {
10497                 if esep {
10498                         for k2, v2 := range v {
10499                                 ee.WriteMapElemKey()
10500                                 ee.EncodeInt(int64(k2))
10501                                 ee.WriteMapElemValue()
10502                                 ee.EncodeUint(uint64(v2))
10503                         }
10504                 } else {
10505                         for k2, v2 := range v {
10506                                 ee.EncodeInt(int64(k2))
10507                                 ee.EncodeUint(uint64(v2))
10508                         }
10509                 }
10510         }
10511         ee.WriteMapEnd()
10512 }
10513
10514 func (e *Encoder) fastpathEncMapIntUint64R(f *codecFnInfo, rv reflect.Value) {
10515         fastpathTV.EncMapIntUint64V(rv2i(rv).(map[int]uint64), e)
10516 }
10517 func (_ fastpathT) EncMapIntUint64V(v map[int]uint64, e *Encoder) {
10518         if v == nil {
10519                 e.e.EncodeNil()
10520                 return
10521         }
10522         ee, esep := e.e, e.hh.hasElemSeparators()
10523         ee.WriteMapStart(len(v))
10524         if e.h.Canonical {
10525                 v2 := make([]int64, len(v))
10526                 var i int
10527                 for k, _ := range v {
10528                         v2[i] = int64(k)
10529                         i++
10530                 }
10531                 sort.Sort(intSlice(v2))
10532                 if esep {
10533                         for _, k2 := range v2 {
10534                                 ee.WriteMapElemKey()
10535                                 ee.EncodeInt(int64(int(k2)))
10536                                 ee.WriteMapElemValue()
10537                                 ee.EncodeUint(uint64(v[int(k2)]))
10538                         }
10539                 } else {
10540                         for _, k2 := range v2 {
10541                                 ee.EncodeInt(int64(int(k2)))
10542                                 ee.EncodeUint(uint64(v[int(k2)]))
10543                         }
10544                 }
10545         } else {
10546                 if esep {
10547                         for k2, v2 := range v {
10548                                 ee.WriteMapElemKey()
10549                                 ee.EncodeInt(int64(k2))
10550                                 ee.WriteMapElemValue()
10551                                 ee.EncodeUint(uint64(v2))
10552                         }
10553                 } else {
10554                         for k2, v2 := range v {
10555                                 ee.EncodeInt(int64(k2))
10556                                 ee.EncodeUint(uint64(v2))
10557                         }
10558                 }
10559         }
10560         ee.WriteMapEnd()
10561 }
10562
10563 func (e *Encoder) fastpathEncMapIntUintptrR(f *codecFnInfo, rv reflect.Value) {
10564         fastpathTV.EncMapIntUintptrV(rv2i(rv).(map[int]uintptr), e)
10565 }
10566 func (_ fastpathT) EncMapIntUintptrV(v map[int]uintptr, e *Encoder) {
10567         if v == nil {
10568                 e.e.EncodeNil()
10569                 return
10570         }
10571         ee, esep := e.e, e.hh.hasElemSeparators()
10572         ee.WriteMapStart(len(v))
10573         if e.h.Canonical {
10574                 v2 := make([]int64, len(v))
10575                 var i int
10576                 for k, _ := range v {
10577                         v2[i] = int64(k)
10578                         i++
10579                 }
10580                 sort.Sort(intSlice(v2))
10581                 if esep {
10582                         for _, k2 := range v2 {
10583                                 ee.WriteMapElemKey()
10584                                 ee.EncodeInt(int64(int(k2)))
10585                                 ee.WriteMapElemValue()
10586                                 e.encode(v[int(k2)])
10587                         }
10588                 } else {
10589                         for _, k2 := range v2 {
10590                                 ee.EncodeInt(int64(int(k2)))
10591                                 e.encode(v[int(k2)])
10592                         }
10593                 }
10594         } else {
10595                 if esep {
10596                         for k2, v2 := range v {
10597                                 ee.WriteMapElemKey()
10598                                 ee.EncodeInt(int64(k2))
10599                                 ee.WriteMapElemValue()
10600                                 e.encode(v2)
10601                         }
10602                 } else {
10603                         for k2, v2 := range v {
10604                                 ee.EncodeInt(int64(k2))
10605                                 e.encode(v2)
10606                         }
10607                 }
10608         }
10609         ee.WriteMapEnd()
10610 }
10611
10612 func (e *Encoder) fastpathEncMapIntIntR(f *codecFnInfo, rv reflect.Value) {
10613         fastpathTV.EncMapIntIntV(rv2i(rv).(map[int]int), e)
10614 }
10615 func (_ fastpathT) EncMapIntIntV(v map[int]int, e *Encoder) {
10616         if v == nil {
10617                 e.e.EncodeNil()
10618                 return
10619         }
10620         ee, esep := e.e, e.hh.hasElemSeparators()
10621         ee.WriteMapStart(len(v))
10622         if e.h.Canonical {
10623                 v2 := make([]int64, len(v))
10624                 var i int
10625                 for k, _ := range v {
10626                         v2[i] = int64(k)
10627                         i++
10628                 }
10629                 sort.Sort(intSlice(v2))
10630                 if esep {
10631                         for _, k2 := range v2 {
10632                                 ee.WriteMapElemKey()
10633                                 ee.EncodeInt(int64(int(k2)))
10634                                 ee.WriteMapElemValue()
10635                                 ee.EncodeInt(int64(v[int(k2)]))
10636                         }
10637                 } else {
10638                         for _, k2 := range v2 {
10639                                 ee.EncodeInt(int64(int(k2)))
10640                                 ee.EncodeInt(int64(v[int(k2)]))
10641                         }
10642                 }
10643         } else {
10644                 if esep {
10645                         for k2, v2 := range v {
10646                                 ee.WriteMapElemKey()
10647                                 ee.EncodeInt(int64(k2))
10648                                 ee.WriteMapElemValue()
10649                                 ee.EncodeInt(int64(v2))
10650                         }
10651                 } else {
10652                         for k2, v2 := range v {
10653                                 ee.EncodeInt(int64(k2))
10654                                 ee.EncodeInt(int64(v2))
10655                         }
10656                 }
10657         }
10658         ee.WriteMapEnd()
10659 }
10660
10661 func (e *Encoder) fastpathEncMapIntInt8R(f *codecFnInfo, rv reflect.Value) {
10662         fastpathTV.EncMapIntInt8V(rv2i(rv).(map[int]int8), e)
10663 }
10664 func (_ fastpathT) EncMapIntInt8V(v map[int]int8, e *Encoder) {
10665         if v == nil {
10666                 e.e.EncodeNil()
10667                 return
10668         }
10669         ee, esep := e.e, e.hh.hasElemSeparators()
10670         ee.WriteMapStart(len(v))
10671         if e.h.Canonical {
10672                 v2 := make([]int64, len(v))
10673                 var i int
10674                 for k, _ := range v {
10675                         v2[i] = int64(k)
10676                         i++
10677                 }
10678                 sort.Sort(intSlice(v2))
10679                 if esep {
10680                         for _, k2 := range v2 {
10681                                 ee.WriteMapElemKey()
10682                                 ee.EncodeInt(int64(int(k2)))
10683                                 ee.WriteMapElemValue()
10684                                 ee.EncodeInt(int64(v[int(k2)]))
10685                         }
10686                 } else {
10687                         for _, k2 := range v2 {
10688                                 ee.EncodeInt(int64(int(k2)))
10689                                 ee.EncodeInt(int64(v[int(k2)]))
10690                         }
10691                 }
10692         } else {
10693                 if esep {
10694                         for k2, v2 := range v {
10695                                 ee.WriteMapElemKey()
10696                                 ee.EncodeInt(int64(k2))
10697                                 ee.WriteMapElemValue()
10698                                 ee.EncodeInt(int64(v2))
10699                         }
10700                 } else {
10701                         for k2, v2 := range v {
10702                                 ee.EncodeInt(int64(k2))
10703                                 ee.EncodeInt(int64(v2))
10704                         }
10705                 }
10706         }
10707         ee.WriteMapEnd()
10708 }
10709
10710 func (e *Encoder) fastpathEncMapIntInt16R(f *codecFnInfo, rv reflect.Value) {
10711         fastpathTV.EncMapIntInt16V(rv2i(rv).(map[int]int16), e)
10712 }
10713 func (_ fastpathT) EncMapIntInt16V(v map[int]int16, e *Encoder) {
10714         if v == nil {
10715                 e.e.EncodeNil()
10716                 return
10717         }
10718         ee, esep := e.e, e.hh.hasElemSeparators()
10719         ee.WriteMapStart(len(v))
10720         if e.h.Canonical {
10721                 v2 := make([]int64, len(v))
10722                 var i int
10723                 for k, _ := range v {
10724                         v2[i] = int64(k)
10725                         i++
10726                 }
10727                 sort.Sort(intSlice(v2))
10728                 if esep {
10729                         for _, k2 := range v2 {
10730                                 ee.WriteMapElemKey()
10731                                 ee.EncodeInt(int64(int(k2)))
10732                                 ee.WriteMapElemValue()
10733                                 ee.EncodeInt(int64(v[int(k2)]))
10734                         }
10735                 } else {
10736                         for _, k2 := range v2 {
10737                                 ee.EncodeInt(int64(int(k2)))
10738                                 ee.EncodeInt(int64(v[int(k2)]))
10739                         }
10740                 }
10741         } else {
10742                 if esep {
10743                         for k2, v2 := range v {
10744                                 ee.WriteMapElemKey()
10745                                 ee.EncodeInt(int64(k2))
10746                                 ee.WriteMapElemValue()
10747                                 ee.EncodeInt(int64(v2))
10748                         }
10749                 } else {
10750                         for k2, v2 := range v {
10751                                 ee.EncodeInt(int64(k2))
10752                                 ee.EncodeInt(int64(v2))
10753                         }
10754                 }
10755         }
10756         ee.WriteMapEnd()
10757 }
10758
10759 func (e *Encoder) fastpathEncMapIntInt32R(f *codecFnInfo, rv reflect.Value) {
10760         fastpathTV.EncMapIntInt32V(rv2i(rv).(map[int]int32), e)
10761 }
10762 func (_ fastpathT) EncMapIntInt32V(v map[int]int32, e *Encoder) {
10763         if v == nil {
10764                 e.e.EncodeNil()
10765                 return
10766         }
10767         ee, esep := e.e, e.hh.hasElemSeparators()
10768         ee.WriteMapStart(len(v))
10769         if e.h.Canonical {
10770                 v2 := make([]int64, len(v))
10771                 var i int
10772                 for k, _ := range v {
10773                         v2[i] = int64(k)
10774                         i++
10775                 }
10776                 sort.Sort(intSlice(v2))
10777                 if esep {
10778                         for _, k2 := range v2 {
10779                                 ee.WriteMapElemKey()
10780                                 ee.EncodeInt(int64(int(k2)))
10781                                 ee.WriteMapElemValue()
10782                                 ee.EncodeInt(int64(v[int(k2)]))
10783                         }
10784                 } else {
10785                         for _, k2 := range v2 {
10786                                 ee.EncodeInt(int64(int(k2)))
10787                                 ee.EncodeInt(int64(v[int(k2)]))
10788                         }
10789                 }
10790         } else {
10791                 if esep {
10792                         for k2, v2 := range v {
10793                                 ee.WriteMapElemKey()
10794                                 ee.EncodeInt(int64(k2))
10795                                 ee.WriteMapElemValue()
10796                                 ee.EncodeInt(int64(v2))
10797                         }
10798                 } else {
10799                         for k2, v2 := range v {
10800                                 ee.EncodeInt(int64(k2))
10801                                 ee.EncodeInt(int64(v2))
10802                         }
10803                 }
10804         }
10805         ee.WriteMapEnd()
10806 }
10807
10808 func (e *Encoder) fastpathEncMapIntInt64R(f *codecFnInfo, rv reflect.Value) {
10809         fastpathTV.EncMapIntInt64V(rv2i(rv).(map[int]int64), e)
10810 }
10811 func (_ fastpathT) EncMapIntInt64V(v map[int]int64, e *Encoder) {
10812         if v == nil {
10813                 e.e.EncodeNil()
10814                 return
10815         }
10816         ee, esep := e.e, e.hh.hasElemSeparators()
10817         ee.WriteMapStart(len(v))
10818         if e.h.Canonical {
10819                 v2 := make([]int64, len(v))
10820                 var i int
10821                 for k, _ := range v {
10822                         v2[i] = int64(k)
10823                         i++
10824                 }
10825                 sort.Sort(intSlice(v2))
10826                 if esep {
10827                         for _, k2 := range v2 {
10828                                 ee.WriteMapElemKey()
10829                                 ee.EncodeInt(int64(int(k2)))
10830                                 ee.WriteMapElemValue()
10831                                 ee.EncodeInt(int64(v[int(k2)]))
10832                         }
10833                 } else {
10834                         for _, k2 := range v2 {
10835                                 ee.EncodeInt(int64(int(k2)))
10836                                 ee.EncodeInt(int64(v[int(k2)]))
10837                         }
10838                 }
10839         } else {
10840                 if esep {
10841                         for k2, v2 := range v {
10842                                 ee.WriteMapElemKey()
10843                                 ee.EncodeInt(int64(k2))
10844                                 ee.WriteMapElemValue()
10845                                 ee.EncodeInt(int64(v2))
10846                         }
10847                 } else {
10848                         for k2, v2 := range v {
10849                                 ee.EncodeInt(int64(k2))
10850                                 ee.EncodeInt(int64(v2))
10851                         }
10852                 }
10853         }
10854         ee.WriteMapEnd()
10855 }
10856
10857 func (e *Encoder) fastpathEncMapIntFloat32R(f *codecFnInfo, rv reflect.Value) {
10858         fastpathTV.EncMapIntFloat32V(rv2i(rv).(map[int]float32), e)
10859 }
10860 func (_ fastpathT) EncMapIntFloat32V(v map[int]float32, e *Encoder) {
10861         if v == nil {
10862                 e.e.EncodeNil()
10863                 return
10864         }
10865         ee, esep := e.e, e.hh.hasElemSeparators()
10866         ee.WriteMapStart(len(v))
10867         if e.h.Canonical {
10868                 v2 := make([]int64, len(v))
10869                 var i int
10870                 for k, _ := range v {
10871                         v2[i] = int64(k)
10872                         i++
10873                 }
10874                 sort.Sort(intSlice(v2))
10875                 if esep {
10876                         for _, k2 := range v2 {
10877                                 ee.WriteMapElemKey()
10878                                 ee.EncodeInt(int64(int(k2)))
10879                                 ee.WriteMapElemValue()
10880                                 ee.EncodeFloat32(v[int(k2)])
10881                         }
10882                 } else {
10883                         for _, k2 := range v2 {
10884                                 ee.EncodeInt(int64(int(k2)))
10885                                 ee.EncodeFloat32(v[int(k2)])
10886                         }
10887                 }
10888         } else {
10889                 if esep {
10890                         for k2, v2 := range v {
10891                                 ee.WriteMapElemKey()
10892                                 ee.EncodeInt(int64(k2))
10893                                 ee.WriteMapElemValue()
10894                                 ee.EncodeFloat32(v2)
10895                         }
10896                 } else {
10897                         for k2, v2 := range v {
10898                                 ee.EncodeInt(int64(k2))
10899                                 ee.EncodeFloat32(v2)
10900                         }
10901                 }
10902         }
10903         ee.WriteMapEnd()
10904 }
10905
10906 func (e *Encoder) fastpathEncMapIntFloat64R(f *codecFnInfo, rv reflect.Value) {
10907         fastpathTV.EncMapIntFloat64V(rv2i(rv).(map[int]float64), e)
10908 }
10909 func (_ fastpathT) EncMapIntFloat64V(v map[int]float64, e *Encoder) {
10910         if v == nil {
10911                 e.e.EncodeNil()
10912                 return
10913         }
10914         ee, esep := e.e, e.hh.hasElemSeparators()
10915         ee.WriteMapStart(len(v))
10916         if e.h.Canonical {
10917                 v2 := make([]int64, len(v))
10918                 var i int
10919                 for k, _ := range v {
10920                         v2[i] = int64(k)
10921                         i++
10922                 }
10923                 sort.Sort(intSlice(v2))
10924                 if esep {
10925                         for _, k2 := range v2 {
10926                                 ee.WriteMapElemKey()
10927                                 ee.EncodeInt(int64(int(k2)))
10928                                 ee.WriteMapElemValue()
10929                                 ee.EncodeFloat64(v[int(k2)])
10930                         }
10931                 } else {
10932                         for _, k2 := range v2 {
10933                                 ee.EncodeInt(int64(int(k2)))
10934                                 ee.EncodeFloat64(v[int(k2)])
10935                         }
10936                 }
10937         } else {
10938                 if esep {
10939                         for k2, v2 := range v {
10940                                 ee.WriteMapElemKey()
10941                                 ee.EncodeInt(int64(k2))
10942                                 ee.WriteMapElemValue()
10943                                 ee.EncodeFloat64(v2)
10944                         }
10945                 } else {
10946                         for k2, v2 := range v {
10947                                 ee.EncodeInt(int64(k2))
10948                                 ee.EncodeFloat64(v2)
10949                         }
10950                 }
10951         }
10952         ee.WriteMapEnd()
10953 }
10954
10955 func (e *Encoder) fastpathEncMapIntBoolR(f *codecFnInfo, rv reflect.Value) {
10956         fastpathTV.EncMapIntBoolV(rv2i(rv).(map[int]bool), e)
10957 }
10958 func (_ fastpathT) EncMapIntBoolV(v map[int]bool, e *Encoder) {
10959         if v == nil {
10960                 e.e.EncodeNil()
10961                 return
10962         }
10963         ee, esep := e.e, e.hh.hasElemSeparators()
10964         ee.WriteMapStart(len(v))
10965         if e.h.Canonical {
10966                 v2 := make([]int64, len(v))
10967                 var i int
10968                 for k, _ := range v {
10969                         v2[i] = int64(k)
10970                         i++
10971                 }
10972                 sort.Sort(intSlice(v2))
10973                 if esep {
10974                         for _, k2 := range v2 {
10975                                 ee.WriteMapElemKey()
10976                                 ee.EncodeInt(int64(int(k2)))
10977                                 ee.WriteMapElemValue()
10978                                 ee.EncodeBool(v[int(k2)])
10979                         }
10980                 } else {
10981                         for _, k2 := range v2 {
10982                                 ee.EncodeInt(int64(int(k2)))
10983                                 ee.EncodeBool(v[int(k2)])
10984                         }
10985                 }
10986         } else {
10987                 if esep {
10988                         for k2, v2 := range v {
10989                                 ee.WriteMapElemKey()
10990                                 ee.EncodeInt(int64(k2))
10991                                 ee.WriteMapElemValue()
10992                                 ee.EncodeBool(v2)
10993                         }
10994                 } else {
10995                         for k2, v2 := range v {
10996                                 ee.EncodeInt(int64(k2))
10997                                 ee.EncodeBool(v2)
10998                         }
10999                 }
11000         }
11001         ee.WriteMapEnd()
11002 }
11003
11004 func (e *Encoder) fastpathEncMapInt8IntfR(f *codecFnInfo, rv reflect.Value) {
11005         fastpathTV.EncMapInt8IntfV(rv2i(rv).(map[int8]interface{}), e)
11006 }
11007 func (_ fastpathT) EncMapInt8IntfV(v map[int8]interface{}, e *Encoder) {
11008         if v == nil {
11009                 e.e.EncodeNil()
11010                 return
11011         }
11012         ee, esep := e.e, e.hh.hasElemSeparators()
11013         ee.WriteMapStart(len(v))
11014         if e.h.Canonical {
11015                 v2 := make([]int64, len(v))
11016                 var i int
11017                 for k, _ := range v {
11018                         v2[i] = int64(k)
11019                         i++
11020                 }
11021                 sort.Sort(intSlice(v2))
11022                 if esep {
11023                         for _, k2 := range v2 {
11024                                 ee.WriteMapElemKey()
11025                                 ee.EncodeInt(int64(int8(k2)))
11026                                 ee.WriteMapElemValue()
11027                                 e.encode(v[int8(k2)])
11028                         }
11029                 } else {
11030                         for _, k2 := range v2 {
11031                                 ee.EncodeInt(int64(int8(k2)))
11032                                 e.encode(v[int8(k2)])
11033                         }
11034                 }
11035         } else {
11036                 if esep {
11037                         for k2, v2 := range v {
11038                                 ee.WriteMapElemKey()
11039                                 ee.EncodeInt(int64(k2))
11040                                 ee.WriteMapElemValue()
11041                                 e.encode(v2)
11042                         }
11043                 } else {
11044                         for k2, v2 := range v {
11045                                 ee.EncodeInt(int64(k2))
11046                                 e.encode(v2)
11047                         }
11048                 }
11049         }
11050         ee.WriteMapEnd()
11051 }
11052
11053 func (e *Encoder) fastpathEncMapInt8StringR(f *codecFnInfo, rv reflect.Value) {
11054         fastpathTV.EncMapInt8StringV(rv2i(rv).(map[int8]string), e)
11055 }
11056 func (_ fastpathT) EncMapInt8StringV(v map[int8]string, e *Encoder) {
11057         if v == nil {
11058                 e.e.EncodeNil()
11059                 return
11060         }
11061         ee, esep := e.e, e.hh.hasElemSeparators()
11062         ee.WriteMapStart(len(v))
11063         if e.h.Canonical {
11064                 v2 := make([]int64, len(v))
11065                 var i int
11066                 for k, _ := range v {
11067                         v2[i] = int64(k)
11068                         i++
11069                 }
11070                 sort.Sort(intSlice(v2))
11071                 if esep {
11072                         for _, k2 := range v2 {
11073                                 ee.WriteMapElemKey()
11074                                 ee.EncodeInt(int64(int8(k2)))
11075                                 ee.WriteMapElemValue()
11076                                 ee.EncodeString(cUTF8, v[int8(k2)])
11077                         }
11078                 } else {
11079                         for _, k2 := range v2 {
11080                                 ee.EncodeInt(int64(int8(k2)))
11081                                 ee.EncodeString(cUTF8, v[int8(k2)])
11082                         }
11083                 }
11084         } else {
11085                 if esep {
11086                         for k2, v2 := range v {
11087                                 ee.WriteMapElemKey()
11088                                 ee.EncodeInt(int64(k2))
11089                                 ee.WriteMapElemValue()
11090                                 ee.EncodeString(cUTF8, v2)
11091                         }
11092                 } else {
11093                         for k2, v2 := range v {
11094                                 ee.EncodeInt(int64(k2))
11095                                 ee.EncodeString(cUTF8, v2)
11096                         }
11097                 }
11098         }
11099         ee.WriteMapEnd()
11100 }
11101
11102 func (e *Encoder) fastpathEncMapInt8UintR(f *codecFnInfo, rv reflect.Value) {
11103         fastpathTV.EncMapInt8UintV(rv2i(rv).(map[int8]uint), e)
11104 }
11105 func (_ fastpathT) EncMapInt8UintV(v map[int8]uint, e *Encoder) {
11106         if v == nil {
11107                 e.e.EncodeNil()
11108                 return
11109         }
11110         ee, esep := e.e, e.hh.hasElemSeparators()
11111         ee.WriteMapStart(len(v))
11112         if e.h.Canonical {
11113                 v2 := make([]int64, len(v))
11114                 var i int
11115                 for k, _ := range v {
11116                         v2[i] = int64(k)
11117                         i++
11118                 }
11119                 sort.Sort(intSlice(v2))
11120                 if esep {
11121                         for _, k2 := range v2 {
11122                                 ee.WriteMapElemKey()
11123                                 ee.EncodeInt(int64(int8(k2)))
11124                                 ee.WriteMapElemValue()
11125                                 ee.EncodeUint(uint64(v[int8(k2)]))
11126                         }
11127                 } else {
11128                         for _, k2 := range v2 {
11129                                 ee.EncodeInt(int64(int8(k2)))
11130                                 ee.EncodeUint(uint64(v[int8(k2)]))
11131                         }
11132                 }
11133         } else {
11134                 if esep {
11135                         for k2, v2 := range v {
11136                                 ee.WriteMapElemKey()
11137                                 ee.EncodeInt(int64(k2))
11138                                 ee.WriteMapElemValue()
11139                                 ee.EncodeUint(uint64(v2))
11140                         }
11141                 } else {
11142                         for k2, v2 := range v {
11143                                 ee.EncodeInt(int64(k2))
11144                                 ee.EncodeUint(uint64(v2))
11145                         }
11146                 }
11147         }
11148         ee.WriteMapEnd()
11149 }
11150
11151 func (e *Encoder) fastpathEncMapInt8Uint8R(f *codecFnInfo, rv reflect.Value) {
11152         fastpathTV.EncMapInt8Uint8V(rv2i(rv).(map[int8]uint8), e)
11153 }
11154 func (_ fastpathT) EncMapInt8Uint8V(v map[int8]uint8, e *Encoder) {
11155         if v == nil {
11156                 e.e.EncodeNil()
11157                 return
11158         }
11159         ee, esep := e.e, e.hh.hasElemSeparators()
11160         ee.WriteMapStart(len(v))
11161         if e.h.Canonical {
11162                 v2 := make([]int64, len(v))
11163                 var i int
11164                 for k, _ := range v {
11165                         v2[i] = int64(k)
11166                         i++
11167                 }
11168                 sort.Sort(intSlice(v2))
11169                 if esep {
11170                         for _, k2 := range v2 {
11171                                 ee.WriteMapElemKey()
11172                                 ee.EncodeInt(int64(int8(k2)))
11173                                 ee.WriteMapElemValue()
11174                                 ee.EncodeUint(uint64(v[int8(k2)]))
11175                         }
11176                 } else {
11177                         for _, k2 := range v2 {
11178                                 ee.EncodeInt(int64(int8(k2)))
11179                                 ee.EncodeUint(uint64(v[int8(k2)]))
11180                         }
11181                 }
11182         } else {
11183                 if esep {
11184                         for k2, v2 := range v {
11185                                 ee.WriteMapElemKey()
11186                                 ee.EncodeInt(int64(k2))
11187                                 ee.WriteMapElemValue()
11188                                 ee.EncodeUint(uint64(v2))
11189                         }
11190                 } else {
11191                         for k2, v2 := range v {
11192                                 ee.EncodeInt(int64(k2))
11193                                 ee.EncodeUint(uint64(v2))
11194                         }
11195                 }
11196         }
11197         ee.WriteMapEnd()
11198 }
11199
11200 func (e *Encoder) fastpathEncMapInt8Uint16R(f *codecFnInfo, rv reflect.Value) {
11201         fastpathTV.EncMapInt8Uint16V(rv2i(rv).(map[int8]uint16), e)
11202 }
11203 func (_ fastpathT) EncMapInt8Uint16V(v map[int8]uint16, e *Encoder) {
11204         if v == nil {
11205                 e.e.EncodeNil()
11206                 return
11207         }
11208         ee, esep := e.e, e.hh.hasElemSeparators()
11209         ee.WriteMapStart(len(v))
11210         if e.h.Canonical {
11211                 v2 := make([]int64, len(v))
11212                 var i int
11213                 for k, _ := range v {
11214                         v2[i] = int64(k)
11215                         i++
11216                 }
11217                 sort.Sort(intSlice(v2))
11218                 if esep {
11219                         for _, k2 := range v2 {
11220                                 ee.WriteMapElemKey()
11221                                 ee.EncodeInt(int64(int8(k2)))
11222                                 ee.WriteMapElemValue()
11223                                 ee.EncodeUint(uint64(v[int8(k2)]))
11224                         }
11225                 } else {
11226                         for _, k2 := range v2 {
11227                                 ee.EncodeInt(int64(int8(k2)))
11228                                 ee.EncodeUint(uint64(v[int8(k2)]))
11229                         }
11230                 }
11231         } else {
11232                 if esep {
11233                         for k2, v2 := range v {
11234                                 ee.WriteMapElemKey()
11235                                 ee.EncodeInt(int64(k2))
11236                                 ee.WriteMapElemValue()
11237                                 ee.EncodeUint(uint64(v2))
11238                         }
11239                 } else {
11240                         for k2, v2 := range v {
11241                                 ee.EncodeInt(int64(k2))
11242                                 ee.EncodeUint(uint64(v2))
11243                         }
11244                 }
11245         }
11246         ee.WriteMapEnd()
11247 }
11248
11249 func (e *Encoder) fastpathEncMapInt8Uint32R(f *codecFnInfo, rv reflect.Value) {
11250         fastpathTV.EncMapInt8Uint32V(rv2i(rv).(map[int8]uint32), e)
11251 }
11252 func (_ fastpathT) EncMapInt8Uint32V(v map[int8]uint32, e *Encoder) {
11253         if v == nil {
11254                 e.e.EncodeNil()
11255                 return
11256         }
11257         ee, esep := e.e, e.hh.hasElemSeparators()
11258         ee.WriteMapStart(len(v))
11259         if e.h.Canonical {
11260                 v2 := make([]int64, len(v))
11261                 var i int
11262                 for k, _ := range v {
11263                         v2[i] = int64(k)
11264                         i++
11265                 }
11266                 sort.Sort(intSlice(v2))
11267                 if esep {
11268                         for _, k2 := range v2 {
11269                                 ee.WriteMapElemKey()
11270                                 ee.EncodeInt(int64(int8(k2)))
11271                                 ee.WriteMapElemValue()
11272                                 ee.EncodeUint(uint64(v[int8(k2)]))
11273                         }
11274                 } else {
11275                         for _, k2 := range v2 {
11276                                 ee.EncodeInt(int64(int8(k2)))
11277                                 ee.EncodeUint(uint64(v[int8(k2)]))
11278                         }
11279                 }
11280         } else {
11281                 if esep {
11282                         for k2, v2 := range v {
11283                                 ee.WriteMapElemKey()
11284                                 ee.EncodeInt(int64(k2))
11285                                 ee.WriteMapElemValue()
11286                                 ee.EncodeUint(uint64(v2))
11287                         }
11288                 } else {
11289                         for k2, v2 := range v {
11290                                 ee.EncodeInt(int64(k2))
11291                                 ee.EncodeUint(uint64(v2))
11292                         }
11293                 }
11294         }
11295         ee.WriteMapEnd()
11296 }
11297
11298 func (e *Encoder) fastpathEncMapInt8Uint64R(f *codecFnInfo, rv reflect.Value) {
11299         fastpathTV.EncMapInt8Uint64V(rv2i(rv).(map[int8]uint64), e)
11300 }
11301 func (_ fastpathT) EncMapInt8Uint64V(v map[int8]uint64, e *Encoder) {
11302         if v == nil {
11303                 e.e.EncodeNil()
11304                 return
11305         }
11306         ee, esep := e.e, e.hh.hasElemSeparators()
11307         ee.WriteMapStart(len(v))
11308         if e.h.Canonical {
11309                 v2 := make([]int64, len(v))
11310                 var i int
11311                 for k, _ := range v {
11312                         v2[i] = int64(k)
11313                         i++
11314                 }
11315                 sort.Sort(intSlice(v2))
11316                 if esep {
11317                         for _, k2 := range v2 {
11318                                 ee.WriteMapElemKey()
11319                                 ee.EncodeInt(int64(int8(k2)))
11320                                 ee.WriteMapElemValue()
11321                                 ee.EncodeUint(uint64(v[int8(k2)]))
11322                         }
11323                 } else {
11324                         for _, k2 := range v2 {
11325                                 ee.EncodeInt(int64(int8(k2)))
11326                                 ee.EncodeUint(uint64(v[int8(k2)]))
11327                         }
11328                 }
11329         } else {
11330                 if esep {
11331                         for k2, v2 := range v {
11332                                 ee.WriteMapElemKey()
11333                                 ee.EncodeInt(int64(k2))
11334                                 ee.WriteMapElemValue()
11335                                 ee.EncodeUint(uint64(v2))
11336                         }
11337                 } else {
11338                         for k2, v2 := range v {
11339                                 ee.EncodeInt(int64(k2))
11340                                 ee.EncodeUint(uint64(v2))
11341                         }
11342                 }
11343         }
11344         ee.WriteMapEnd()
11345 }
11346
11347 func (e *Encoder) fastpathEncMapInt8UintptrR(f *codecFnInfo, rv reflect.Value) {
11348         fastpathTV.EncMapInt8UintptrV(rv2i(rv).(map[int8]uintptr), e)
11349 }
11350 func (_ fastpathT) EncMapInt8UintptrV(v map[int8]uintptr, e *Encoder) {
11351         if v == nil {
11352                 e.e.EncodeNil()
11353                 return
11354         }
11355         ee, esep := e.e, e.hh.hasElemSeparators()
11356         ee.WriteMapStart(len(v))
11357         if e.h.Canonical {
11358                 v2 := make([]int64, len(v))
11359                 var i int
11360                 for k, _ := range v {
11361                         v2[i] = int64(k)
11362                         i++
11363                 }
11364                 sort.Sort(intSlice(v2))
11365                 if esep {
11366                         for _, k2 := range v2 {
11367                                 ee.WriteMapElemKey()
11368                                 ee.EncodeInt(int64(int8(k2)))
11369                                 ee.WriteMapElemValue()
11370                                 e.encode(v[int8(k2)])
11371                         }
11372                 } else {
11373                         for _, k2 := range v2 {
11374                                 ee.EncodeInt(int64(int8(k2)))
11375                                 e.encode(v[int8(k2)])
11376                         }
11377                 }
11378         } else {
11379                 if esep {
11380                         for k2, v2 := range v {
11381                                 ee.WriteMapElemKey()
11382                                 ee.EncodeInt(int64(k2))
11383                                 ee.WriteMapElemValue()
11384                                 e.encode(v2)
11385                         }
11386                 } else {
11387                         for k2, v2 := range v {
11388                                 ee.EncodeInt(int64(k2))
11389                                 e.encode(v2)
11390                         }
11391                 }
11392         }
11393         ee.WriteMapEnd()
11394 }
11395
11396 func (e *Encoder) fastpathEncMapInt8IntR(f *codecFnInfo, rv reflect.Value) {
11397         fastpathTV.EncMapInt8IntV(rv2i(rv).(map[int8]int), e)
11398 }
11399 func (_ fastpathT) EncMapInt8IntV(v map[int8]int, e *Encoder) {
11400         if v == nil {
11401                 e.e.EncodeNil()
11402                 return
11403         }
11404         ee, esep := e.e, e.hh.hasElemSeparators()
11405         ee.WriteMapStart(len(v))
11406         if e.h.Canonical {
11407                 v2 := make([]int64, len(v))
11408                 var i int
11409                 for k, _ := range v {
11410                         v2[i] = int64(k)
11411                         i++
11412                 }
11413                 sort.Sort(intSlice(v2))
11414                 if esep {
11415                         for _, k2 := range v2 {
11416                                 ee.WriteMapElemKey()
11417                                 ee.EncodeInt(int64(int8(k2)))
11418                                 ee.WriteMapElemValue()
11419                                 ee.EncodeInt(int64(v[int8(k2)]))
11420                         }
11421                 } else {
11422                         for _, k2 := range v2 {
11423                                 ee.EncodeInt(int64(int8(k2)))
11424                                 ee.EncodeInt(int64(v[int8(k2)]))
11425                         }
11426                 }
11427         } else {
11428                 if esep {
11429                         for k2, v2 := range v {
11430                                 ee.WriteMapElemKey()
11431                                 ee.EncodeInt(int64(k2))
11432                                 ee.WriteMapElemValue()
11433                                 ee.EncodeInt(int64(v2))
11434                         }
11435                 } else {
11436                         for k2, v2 := range v {
11437                                 ee.EncodeInt(int64(k2))
11438                                 ee.EncodeInt(int64(v2))
11439                         }
11440                 }
11441         }
11442         ee.WriteMapEnd()
11443 }
11444
11445 func (e *Encoder) fastpathEncMapInt8Int8R(f *codecFnInfo, rv reflect.Value) {
11446         fastpathTV.EncMapInt8Int8V(rv2i(rv).(map[int8]int8), e)
11447 }
11448 func (_ fastpathT) EncMapInt8Int8V(v map[int8]int8, e *Encoder) {
11449         if v == nil {
11450                 e.e.EncodeNil()
11451                 return
11452         }
11453         ee, esep := e.e, e.hh.hasElemSeparators()
11454         ee.WriteMapStart(len(v))
11455         if e.h.Canonical {
11456                 v2 := make([]int64, len(v))
11457                 var i int
11458                 for k, _ := range v {
11459                         v2[i] = int64(k)
11460                         i++
11461                 }
11462                 sort.Sort(intSlice(v2))
11463                 if esep {
11464                         for _, k2 := range v2 {
11465                                 ee.WriteMapElemKey()
11466                                 ee.EncodeInt(int64(int8(k2)))
11467                                 ee.WriteMapElemValue()
11468                                 ee.EncodeInt(int64(v[int8(k2)]))
11469                         }
11470                 } else {
11471                         for _, k2 := range v2 {
11472                                 ee.EncodeInt(int64(int8(k2)))
11473                                 ee.EncodeInt(int64(v[int8(k2)]))
11474                         }
11475                 }
11476         } else {
11477                 if esep {
11478                         for k2, v2 := range v {
11479                                 ee.WriteMapElemKey()
11480                                 ee.EncodeInt(int64(k2))
11481                                 ee.WriteMapElemValue()
11482                                 ee.EncodeInt(int64(v2))
11483                         }
11484                 } else {
11485                         for k2, v2 := range v {
11486                                 ee.EncodeInt(int64(k2))
11487                                 ee.EncodeInt(int64(v2))
11488                         }
11489                 }
11490         }
11491         ee.WriteMapEnd()
11492 }
11493
11494 func (e *Encoder) fastpathEncMapInt8Int16R(f *codecFnInfo, rv reflect.Value) {
11495         fastpathTV.EncMapInt8Int16V(rv2i(rv).(map[int8]int16), e)
11496 }
11497 func (_ fastpathT) EncMapInt8Int16V(v map[int8]int16, e *Encoder) {
11498         if v == nil {
11499                 e.e.EncodeNil()
11500                 return
11501         }
11502         ee, esep := e.e, e.hh.hasElemSeparators()
11503         ee.WriteMapStart(len(v))
11504         if e.h.Canonical {
11505                 v2 := make([]int64, len(v))
11506                 var i int
11507                 for k, _ := range v {
11508                         v2[i] = int64(k)
11509                         i++
11510                 }
11511                 sort.Sort(intSlice(v2))
11512                 if esep {
11513                         for _, k2 := range v2 {
11514                                 ee.WriteMapElemKey()
11515                                 ee.EncodeInt(int64(int8(k2)))
11516                                 ee.WriteMapElemValue()
11517                                 ee.EncodeInt(int64(v[int8(k2)]))
11518                         }
11519                 } else {
11520                         for _, k2 := range v2 {
11521                                 ee.EncodeInt(int64(int8(k2)))
11522                                 ee.EncodeInt(int64(v[int8(k2)]))
11523                         }
11524                 }
11525         } else {
11526                 if esep {
11527                         for k2, v2 := range v {
11528                                 ee.WriteMapElemKey()
11529                                 ee.EncodeInt(int64(k2))
11530                                 ee.WriteMapElemValue()
11531                                 ee.EncodeInt(int64(v2))
11532                         }
11533                 } else {
11534                         for k2, v2 := range v {
11535                                 ee.EncodeInt(int64(k2))
11536                                 ee.EncodeInt(int64(v2))
11537                         }
11538                 }
11539         }
11540         ee.WriteMapEnd()
11541 }
11542
11543 func (e *Encoder) fastpathEncMapInt8Int32R(f *codecFnInfo, rv reflect.Value) {
11544         fastpathTV.EncMapInt8Int32V(rv2i(rv).(map[int8]int32), e)
11545 }
11546 func (_ fastpathT) EncMapInt8Int32V(v map[int8]int32, e *Encoder) {
11547         if v == nil {
11548                 e.e.EncodeNil()
11549                 return
11550         }
11551         ee, esep := e.e, e.hh.hasElemSeparators()
11552         ee.WriteMapStart(len(v))
11553         if e.h.Canonical {
11554                 v2 := make([]int64, len(v))
11555                 var i int
11556                 for k, _ := range v {
11557                         v2[i] = int64(k)
11558                         i++
11559                 }
11560                 sort.Sort(intSlice(v2))
11561                 if esep {
11562                         for _, k2 := range v2 {
11563                                 ee.WriteMapElemKey()
11564                                 ee.EncodeInt(int64(int8(k2)))
11565                                 ee.WriteMapElemValue()
11566                                 ee.EncodeInt(int64(v[int8(k2)]))
11567                         }
11568                 } else {
11569                         for _, k2 := range v2 {
11570                                 ee.EncodeInt(int64(int8(k2)))
11571                                 ee.EncodeInt(int64(v[int8(k2)]))
11572                         }
11573                 }
11574         } else {
11575                 if esep {
11576                         for k2, v2 := range v {
11577                                 ee.WriteMapElemKey()
11578                                 ee.EncodeInt(int64(k2))
11579                                 ee.WriteMapElemValue()
11580                                 ee.EncodeInt(int64(v2))
11581                         }
11582                 } else {
11583                         for k2, v2 := range v {
11584                                 ee.EncodeInt(int64(k2))
11585                                 ee.EncodeInt(int64(v2))
11586                         }
11587                 }
11588         }
11589         ee.WriteMapEnd()
11590 }
11591
11592 func (e *Encoder) fastpathEncMapInt8Int64R(f *codecFnInfo, rv reflect.Value) {
11593         fastpathTV.EncMapInt8Int64V(rv2i(rv).(map[int8]int64), e)
11594 }
11595 func (_ fastpathT) EncMapInt8Int64V(v map[int8]int64, e *Encoder) {
11596         if v == nil {
11597                 e.e.EncodeNil()
11598                 return
11599         }
11600         ee, esep := e.e, e.hh.hasElemSeparators()
11601         ee.WriteMapStart(len(v))
11602         if e.h.Canonical {
11603                 v2 := make([]int64, len(v))
11604                 var i int
11605                 for k, _ := range v {
11606                         v2[i] = int64(k)
11607                         i++
11608                 }
11609                 sort.Sort(intSlice(v2))
11610                 if esep {
11611                         for _, k2 := range v2 {
11612                                 ee.WriteMapElemKey()
11613                                 ee.EncodeInt(int64(int8(k2)))
11614                                 ee.WriteMapElemValue()
11615                                 ee.EncodeInt(int64(v[int8(k2)]))
11616                         }
11617                 } else {
11618                         for _, k2 := range v2 {
11619                                 ee.EncodeInt(int64(int8(k2)))
11620                                 ee.EncodeInt(int64(v[int8(k2)]))
11621                         }
11622                 }
11623         } else {
11624                 if esep {
11625                         for k2, v2 := range v {
11626                                 ee.WriteMapElemKey()
11627                                 ee.EncodeInt(int64(k2))
11628                                 ee.WriteMapElemValue()
11629                                 ee.EncodeInt(int64(v2))
11630                         }
11631                 } else {
11632                         for k2, v2 := range v {
11633                                 ee.EncodeInt(int64(k2))
11634                                 ee.EncodeInt(int64(v2))
11635                         }
11636                 }
11637         }
11638         ee.WriteMapEnd()
11639 }
11640
11641 func (e *Encoder) fastpathEncMapInt8Float32R(f *codecFnInfo, rv reflect.Value) {
11642         fastpathTV.EncMapInt8Float32V(rv2i(rv).(map[int8]float32), e)
11643 }
11644 func (_ fastpathT) EncMapInt8Float32V(v map[int8]float32, e *Encoder) {
11645         if v == nil {
11646                 e.e.EncodeNil()
11647                 return
11648         }
11649         ee, esep := e.e, e.hh.hasElemSeparators()
11650         ee.WriteMapStart(len(v))
11651         if e.h.Canonical {
11652                 v2 := make([]int64, len(v))
11653                 var i int
11654                 for k, _ := range v {
11655                         v2[i] = int64(k)
11656                         i++
11657                 }
11658                 sort.Sort(intSlice(v2))
11659                 if esep {
11660                         for _, k2 := range v2 {
11661                                 ee.WriteMapElemKey()
11662                                 ee.EncodeInt(int64(int8(k2)))
11663                                 ee.WriteMapElemValue()
11664                                 ee.EncodeFloat32(v[int8(k2)])
11665                         }
11666                 } else {
11667                         for _, k2 := range v2 {
11668                                 ee.EncodeInt(int64(int8(k2)))
11669                                 ee.EncodeFloat32(v[int8(k2)])
11670                         }
11671                 }
11672         } else {
11673                 if esep {
11674                         for k2, v2 := range v {
11675                                 ee.WriteMapElemKey()
11676                                 ee.EncodeInt(int64(k2))
11677                                 ee.WriteMapElemValue()
11678                                 ee.EncodeFloat32(v2)
11679                         }
11680                 } else {
11681                         for k2, v2 := range v {
11682                                 ee.EncodeInt(int64(k2))
11683                                 ee.EncodeFloat32(v2)
11684                         }
11685                 }
11686         }
11687         ee.WriteMapEnd()
11688 }
11689
11690 func (e *Encoder) fastpathEncMapInt8Float64R(f *codecFnInfo, rv reflect.Value) {
11691         fastpathTV.EncMapInt8Float64V(rv2i(rv).(map[int8]float64), e)
11692 }
11693 func (_ fastpathT) EncMapInt8Float64V(v map[int8]float64, e *Encoder) {
11694         if v == nil {
11695                 e.e.EncodeNil()
11696                 return
11697         }
11698         ee, esep := e.e, e.hh.hasElemSeparators()
11699         ee.WriteMapStart(len(v))
11700         if e.h.Canonical {
11701                 v2 := make([]int64, len(v))
11702                 var i int
11703                 for k, _ := range v {
11704                         v2[i] = int64(k)
11705                         i++
11706                 }
11707                 sort.Sort(intSlice(v2))
11708                 if esep {
11709                         for _, k2 := range v2 {
11710                                 ee.WriteMapElemKey()
11711                                 ee.EncodeInt(int64(int8(k2)))
11712                                 ee.WriteMapElemValue()
11713                                 ee.EncodeFloat64(v[int8(k2)])
11714                         }
11715                 } else {
11716                         for _, k2 := range v2 {
11717                                 ee.EncodeInt(int64(int8(k2)))
11718                                 ee.EncodeFloat64(v[int8(k2)])
11719                         }
11720                 }
11721         } else {
11722                 if esep {
11723                         for k2, v2 := range v {
11724                                 ee.WriteMapElemKey()
11725                                 ee.EncodeInt(int64(k2))
11726                                 ee.WriteMapElemValue()
11727                                 ee.EncodeFloat64(v2)
11728                         }
11729                 } else {
11730                         for k2, v2 := range v {
11731                                 ee.EncodeInt(int64(k2))
11732                                 ee.EncodeFloat64(v2)
11733                         }
11734                 }
11735         }
11736         ee.WriteMapEnd()
11737 }
11738
11739 func (e *Encoder) fastpathEncMapInt8BoolR(f *codecFnInfo, rv reflect.Value) {
11740         fastpathTV.EncMapInt8BoolV(rv2i(rv).(map[int8]bool), e)
11741 }
11742 func (_ fastpathT) EncMapInt8BoolV(v map[int8]bool, e *Encoder) {
11743         if v == nil {
11744                 e.e.EncodeNil()
11745                 return
11746         }
11747         ee, esep := e.e, e.hh.hasElemSeparators()
11748         ee.WriteMapStart(len(v))
11749         if e.h.Canonical {
11750                 v2 := make([]int64, len(v))
11751                 var i int
11752                 for k, _ := range v {
11753                         v2[i] = int64(k)
11754                         i++
11755                 }
11756                 sort.Sort(intSlice(v2))
11757                 if esep {
11758                         for _, k2 := range v2 {
11759                                 ee.WriteMapElemKey()
11760                                 ee.EncodeInt(int64(int8(k2)))
11761                                 ee.WriteMapElemValue()
11762                                 ee.EncodeBool(v[int8(k2)])
11763                         }
11764                 } else {
11765                         for _, k2 := range v2 {
11766                                 ee.EncodeInt(int64(int8(k2)))
11767                                 ee.EncodeBool(v[int8(k2)])
11768                         }
11769                 }
11770         } else {
11771                 if esep {
11772                         for k2, v2 := range v {
11773                                 ee.WriteMapElemKey()
11774                                 ee.EncodeInt(int64(k2))
11775                                 ee.WriteMapElemValue()
11776                                 ee.EncodeBool(v2)
11777                         }
11778                 } else {
11779                         for k2, v2 := range v {
11780                                 ee.EncodeInt(int64(k2))
11781                                 ee.EncodeBool(v2)
11782                         }
11783                 }
11784         }
11785         ee.WriteMapEnd()
11786 }
11787
11788 func (e *Encoder) fastpathEncMapInt16IntfR(f *codecFnInfo, rv reflect.Value) {
11789         fastpathTV.EncMapInt16IntfV(rv2i(rv).(map[int16]interface{}), e)
11790 }
11791 func (_ fastpathT) EncMapInt16IntfV(v map[int16]interface{}, e *Encoder) {
11792         if v == nil {
11793                 e.e.EncodeNil()
11794                 return
11795         }
11796         ee, esep := e.e, e.hh.hasElemSeparators()
11797         ee.WriteMapStart(len(v))
11798         if e.h.Canonical {
11799                 v2 := make([]int64, len(v))
11800                 var i int
11801                 for k, _ := range v {
11802                         v2[i] = int64(k)
11803                         i++
11804                 }
11805                 sort.Sort(intSlice(v2))
11806                 if esep {
11807                         for _, k2 := range v2 {
11808                                 ee.WriteMapElemKey()
11809                                 ee.EncodeInt(int64(int16(k2)))
11810                                 ee.WriteMapElemValue()
11811                                 e.encode(v[int16(k2)])
11812                         }
11813                 } else {
11814                         for _, k2 := range v2 {
11815                                 ee.EncodeInt(int64(int16(k2)))
11816                                 e.encode(v[int16(k2)])
11817                         }
11818                 }
11819         } else {
11820                 if esep {
11821                         for k2, v2 := range v {
11822                                 ee.WriteMapElemKey()
11823                                 ee.EncodeInt(int64(k2))
11824                                 ee.WriteMapElemValue()
11825                                 e.encode(v2)
11826                         }
11827                 } else {
11828                         for k2, v2 := range v {
11829                                 ee.EncodeInt(int64(k2))
11830                                 e.encode(v2)
11831                         }
11832                 }
11833         }
11834         ee.WriteMapEnd()
11835 }
11836
11837 func (e *Encoder) fastpathEncMapInt16StringR(f *codecFnInfo, rv reflect.Value) {
11838         fastpathTV.EncMapInt16StringV(rv2i(rv).(map[int16]string), e)
11839 }
11840 func (_ fastpathT) EncMapInt16StringV(v map[int16]string, e *Encoder) {
11841         if v == nil {
11842                 e.e.EncodeNil()
11843                 return
11844         }
11845         ee, esep := e.e, e.hh.hasElemSeparators()
11846         ee.WriteMapStart(len(v))
11847         if e.h.Canonical {
11848                 v2 := make([]int64, len(v))
11849                 var i int
11850                 for k, _ := range v {
11851                         v2[i] = int64(k)
11852                         i++
11853                 }
11854                 sort.Sort(intSlice(v2))
11855                 if esep {
11856                         for _, k2 := range v2 {
11857                                 ee.WriteMapElemKey()
11858                                 ee.EncodeInt(int64(int16(k2)))
11859                                 ee.WriteMapElemValue()
11860                                 ee.EncodeString(cUTF8, v[int16(k2)])
11861                         }
11862                 } else {
11863                         for _, k2 := range v2 {
11864                                 ee.EncodeInt(int64(int16(k2)))
11865                                 ee.EncodeString(cUTF8, v[int16(k2)])
11866                         }
11867                 }
11868         } else {
11869                 if esep {
11870                         for k2, v2 := range v {
11871                                 ee.WriteMapElemKey()
11872                                 ee.EncodeInt(int64(k2))
11873                                 ee.WriteMapElemValue()
11874                                 ee.EncodeString(cUTF8, v2)
11875                         }
11876                 } else {
11877                         for k2, v2 := range v {
11878                                 ee.EncodeInt(int64(k2))
11879                                 ee.EncodeString(cUTF8, v2)
11880                         }
11881                 }
11882         }
11883         ee.WriteMapEnd()
11884 }
11885
11886 func (e *Encoder) fastpathEncMapInt16UintR(f *codecFnInfo, rv reflect.Value) {
11887         fastpathTV.EncMapInt16UintV(rv2i(rv).(map[int16]uint), e)
11888 }
11889 func (_ fastpathT) EncMapInt16UintV(v map[int16]uint, e *Encoder) {
11890         if v == nil {
11891                 e.e.EncodeNil()
11892                 return
11893         }
11894         ee, esep := e.e, e.hh.hasElemSeparators()
11895         ee.WriteMapStart(len(v))
11896         if e.h.Canonical {
11897                 v2 := make([]int64, len(v))
11898                 var i int
11899                 for k, _ := range v {
11900                         v2[i] = int64(k)
11901                         i++
11902                 }
11903                 sort.Sort(intSlice(v2))
11904                 if esep {
11905                         for _, k2 := range v2 {
11906                                 ee.WriteMapElemKey()
11907                                 ee.EncodeInt(int64(int16(k2)))
11908                                 ee.WriteMapElemValue()
11909                                 ee.EncodeUint(uint64(v[int16(k2)]))
11910                         }
11911                 } else {
11912                         for _, k2 := range v2 {
11913                                 ee.EncodeInt(int64(int16(k2)))
11914                                 ee.EncodeUint(uint64(v[int16(k2)]))
11915                         }
11916                 }
11917         } else {
11918                 if esep {
11919                         for k2, v2 := range v {
11920                                 ee.WriteMapElemKey()
11921                                 ee.EncodeInt(int64(k2))
11922                                 ee.WriteMapElemValue()
11923                                 ee.EncodeUint(uint64(v2))
11924                         }
11925                 } else {
11926                         for k2, v2 := range v {
11927                                 ee.EncodeInt(int64(k2))
11928                                 ee.EncodeUint(uint64(v2))
11929                         }
11930                 }
11931         }
11932         ee.WriteMapEnd()
11933 }
11934
11935 func (e *Encoder) fastpathEncMapInt16Uint8R(f *codecFnInfo, rv reflect.Value) {
11936         fastpathTV.EncMapInt16Uint8V(rv2i(rv).(map[int16]uint8), e)
11937 }
11938 func (_ fastpathT) EncMapInt16Uint8V(v map[int16]uint8, e *Encoder) {
11939         if v == nil {
11940                 e.e.EncodeNil()
11941                 return
11942         }
11943         ee, esep := e.e, e.hh.hasElemSeparators()
11944         ee.WriteMapStart(len(v))
11945         if e.h.Canonical {
11946                 v2 := make([]int64, len(v))
11947                 var i int
11948                 for k, _ := range v {
11949                         v2[i] = int64(k)
11950                         i++
11951                 }
11952                 sort.Sort(intSlice(v2))
11953                 if esep {
11954                         for _, k2 := range v2 {
11955                                 ee.WriteMapElemKey()
11956                                 ee.EncodeInt(int64(int16(k2)))
11957                                 ee.WriteMapElemValue()
11958                                 ee.EncodeUint(uint64(v[int16(k2)]))
11959                         }
11960                 } else {
11961                         for _, k2 := range v2 {
11962                                 ee.EncodeInt(int64(int16(k2)))
11963                                 ee.EncodeUint(uint64(v[int16(k2)]))
11964                         }
11965                 }
11966         } else {
11967                 if esep {
11968                         for k2, v2 := range v {
11969                                 ee.WriteMapElemKey()
11970                                 ee.EncodeInt(int64(k2))
11971                                 ee.WriteMapElemValue()
11972                                 ee.EncodeUint(uint64(v2))
11973                         }
11974                 } else {
11975                         for k2, v2 := range v {
11976                                 ee.EncodeInt(int64(k2))
11977                                 ee.EncodeUint(uint64(v2))
11978                         }
11979                 }
11980         }
11981         ee.WriteMapEnd()
11982 }
11983
11984 func (e *Encoder) fastpathEncMapInt16Uint16R(f *codecFnInfo, rv reflect.Value) {
11985         fastpathTV.EncMapInt16Uint16V(rv2i(rv).(map[int16]uint16), e)
11986 }
11987 func (_ fastpathT) EncMapInt16Uint16V(v map[int16]uint16, e *Encoder) {
11988         if v == nil {
11989                 e.e.EncodeNil()
11990                 return
11991         }
11992         ee, esep := e.e, e.hh.hasElemSeparators()
11993         ee.WriteMapStart(len(v))
11994         if e.h.Canonical {
11995                 v2 := make([]int64, len(v))
11996                 var i int
11997                 for k, _ := range v {
11998                         v2[i] = int64(k)
11999                         i++
12000                 }
12001                 sort.Sort(intSlice(v2))
12002                 if esep {
12003                         for _, k2 := range v2 {
12004                                 ee.WriteMapElemKey()
12005                                 ee.EncodeInt(int64(int16(k2)))
12006                                 ee.WriteMapElemValue()
12007                                 ee.EncodeUint(uint64(v[int16(k2)]))
12008                         }
12009                 } else {
12010                         for _, k2 := range v2 {
12011                                 ee.EncodeInt(int64(int16(k2)))
12012                                 ee.EncodeUint(uint64(v[int16(k2)]))
12013                         }
12014                 }
12015         } else {
12016                 if esep {
12017                         for k2, v2 := range v {
12018                                 ee.WriteMapElemKey()
12019                                 ee.EncodeInt(int64(k2))
12020                                 ee.WriteMapElemValue()
12021                                 ee.EncodeUint(uint64(v2))
12022                         }
12023                 } else {
12024                         for k2, v2 := range v {
12025                                 ee.EncodeInt(int64(k2))
12026                                 ee.EncodeUint(uint64(v2))
12027                         }
12028                 }
12029         }
12030         ee.WriteMapEnd()
12031 }
12032
12033 func (e *Encoder) fastpathEncMapInt16Uint32R(f *codecFnInfo, rv reflect.Value) {
12034         fastpathTV.EncMapInt16Uint32V(rv2i(rv).(map[int16]uint32), e)
12035 }
12036 func (_ fastpathT) EncMapInt16Uint32V(v map[int16]uint32, e *Encoder) {
12037         if v == nil {
12038                 e.e.EncodeNil()
12039                 return
12040         }
12041         ee, esep := e.e, e.hh.hasElemSeparators()
12042         ee.WriteMapStart(len(v))
12043         if e.h.Canonical {
12044                 v2 := make([]int64, len(v))
12045                 var i int
12046                 for k, _ := range v {
12047                         v2[i] = int64(k)
12048                         i++
12049                 }
12050                 sort.Sort(intSlice(v2))
12051                 if esep {
12052                         for _, k2 := range v2 {
12053                                 ee.WriteMapElemKey()
12054                                 ee.EncodeInt(int64(int16(k2)))
12055                                 ee.WriteMapElemValue()
12056                                 ee.EncodeUint(uint64(v[int16(k2)]))
12057                         }
12058                 } else {
12059                         for _, k2 := range v2 {
12060                                 ee.EncodeInt(int64(int16(k2)))
12061                                 ee.EncodeUint(uint64(v[int16(k2)]))
12062                         }
12063                 }
12064         } else {
12065                 if esep {
12066                         for k2, v2 := range v {
12067                                 ee.WriteMapElemKey()
12068                                 ee.EncodeInt(int64(k2))
12069                                 ee.WriteMapElemValue()
12070                                 ee.EncodeUint(uint64(v2))
12071                         }
12072                 } else {
12073                         for k2, v2 := range v {
12074                                 ee.EncodeInt(int64(k2))
12075                                 ee.EncodeUint(uint64(v2))
12076                         }
12077                 }
12078         }
12079         ee.WriteMapEnd()
12080 }
12081
12082 func (e *Encoder) fastpathEncMapInt16Uint64R(f *codecFnInfo, rv reflect.Value) {
12083         fastpathTV.EncMapInt16Uint64V(rv2i(rv).(map[int16]uint64), e)
12084 }
12085 func (_ fastpathT) EncMapInt16Uint64V(v map[int16]uint64, e *Encoder) {
12086         if v == nil {
12087                 e.e.EncodeNil()
12088                 return
12089         }
12090         ee, esep := e.e, e.hh.hasElemSeparators()
12091         ee.WriteMapStart(len(v))
12092         if e.h.Canonical {
12093                 v2 := make([]int64, len(v))
12094                 var i int
12095                 for k, _ := range v {
12096                         v2[i] = int64(k)
12097                         i++
12098                 }
12099                 sort.Sort(intSlice(v2))
12100                 if esep {
12101                         for _, k2 := range v2 {
12102                                 ee.WriteMapElemKey()
12103                                 ee.EncodeInt(int64(int16(k2)))
12104                                 ee.WriteMapElemValue()
12105                                 ee.EncodeUint(uint64(v[int16(k2)]))
12106                         }
12107                 } else {
12108                         for _, k2 := range v2 {
12109                                 ee.EncodeInt(int64(int16(k2)))
12110                                 ee.EncodeUint(uint64(v[int16(k2)]))
12111                         }
12112                 }
12113         } else {
12114                 if esep {
12115                         for k2, v2 := range v {
12116                                 ee.WriteMapElemKey()
12117                                 ee.EncodeInt(int64(k2))
12118                                 ee.WriteMapElemValue()
12119                                 ee.EncodeUint(uint64(v2))
12120                         }
12121                 } else {
12122                         for k2, v2 := range v {
12123                                 ee.EncodeInt(int64(k2))
12124                                 ee.EncodeUint(uint64(v2))
12125                         }
12126                 }
12127         }
12128         ee.WriteMapEnd()
12129 }
12130
12131 func (e *Encoder) fastpathEncMapInt16UintptrR(f *codecFnInfo, rv reflect.Value) {
12132         fastpathTV.EncMapInt16UintptrV(rv2i(rv).(map[int16]uintptr), e)
12133 }
12134 func (_ fastpathT) EncMapInt16UintptrV(v map[int16]uintptr, e *Encoder) {
12135         if v == nil {
12136                 e.e.EncodeNil()
12137                 return
12138         }
12139         ee, esep := e.e, e.hh.hasElemSeparators()
12140         ee.WriteMapStart(len(v))
12141         if e.h.Canonical {
12142                 v2 := make([]int64, len(v))
12143                 var i int
12144                 for k, _ := range v {
12145                         v2[i] = int64(k)
12146                         i++
12147                 }
12148                 sort.Sort(intSlice(v2))
12149                 if esep {
12150                         for _, k2 := range v2 {
12151                                 ee.WriteMapElemKey()
12152                                 ee.EncodeInt(int64(int16(k2)))
12153                                 ee.WriteMapElemValue()
12154                                 e.encode(v[int16(k2)])
12155                         }
12156                 } else {
12157                         for _, k2 := range v2 {
12158                                 ee.EncodeInt(int64(int16(k2)))
12159                                 e.encode(v[int16(k2)])
12160                         }
12161                 }
12162         } else {
12163                 if esep {
12164                         for k2, v2 := range v {
12165                                 ee.WriteMapElemKey()
12166                                 ee.EncodeInt(int64(k2))
12167                                 ee.WriteMapElemValue()
12168                                 e.encode(v2)
12169                         }
12170                 } else {
12171                         for k2, v2 := range v {
12172                                 ee.EncodeInt(int64(k2))
12173                                 e.encode(v2)
12174                         }
12175                 }
12176         }
12177         ee.WriteMapEnd()
12178 }
12179
12180 func (e *Encoder) fastpathEncMapInt16IntR(f *codecFnInfo, rv reflect.Value) {
12181         fastpathTV.EncMapInt16IntV(rv2i(rv).(map[int16]int), e)
12182 }
12183 func (_ fastpathT) EncMapInt16IntV(v map[int16]int, e *Encoder) {
12184         if v == nil {
12185                 e.e.EncodeNil()
12186                 return
12187         }
12188         ee, esep := e.e, e.hh.hasElemSeparators()
12189         ee.WriteMapStart(len(v))
12190         if e.h.Canonical {
12191                 v2 := make([]int64, len(v))
12192                 var i int
12193                 for k, _ := range v {
12194                         v2[i] = int64(k)
12195                         i++
12196                 }
12197                 sort.Sort(intSlice(v2))
12198                 if esep {
12199                         for _, k2 := range v2 {
12200                                 ee.WriteMapElemKey()
12201                                 ee.EncodeInt(int64(int16(k2)))
12202                                 ee.WriteMapElemValue()
12203                                 ee.EncodeInt(int64(v[int16(k2)]))
12204                         }
12205                 } else {
12206                         for _, k2 := range v2 {
12207                                 ee.EncodeInt(int64(int16(k2)))
12208                                 ee.EncodeInt(int64(v[int16(k2)]))
12209                         }
12210                 }
12211         } else {
12212                 if esep {
12213                         for k2, v2 := range v {
12214                                 ee.WriteMapElemKey()
12215                                 ee.EncodeInt(int64(k2))
12216                                 ee.WriteMapElemValue()
12217                                 ee.EncodeInt(int64(v2))
12218                         }
12219                 } else {
12220                         for k2, v2 := range v {
12221                                 ee.EncodeInt(int64(k2))
12222                                 ee.EncodeInt(int64(v2))
12223                         }
12224                 }
12225         }
12226         ee.WriteMapEnd()
12227 }
12228
12229 func (e *Encoder) fastpathEncMapInt16Int8R(f *codecFnInfo, rv reflect.Value) {
12230         fastpathTV.EncMapInt16Int8V(rv2i(rv).(map[int16]int8), e)
12231 }
12232 func (_ fastpathT) EncMapInt16Int8V(v map[int16]int8, e *Encoder) {
12233         if v == nil {
12234                 e.e.EncodeNil()
12235                 return
12236         }
12237         ee, esep := e.e, e.hh.hasElemSeparators()
12238         ee.WriteMapStart(len(v))
12239         if e.h.Canonical {
12240                 v2 := make([]int64, len(v))
12241                 var i int
12242                 for k, _ := range v {
12243                         v2[i] = int64(k)
12244                         i++
12245                 }
12246                 sort.Sort(intSlice(v2))
12247                 if esep {
12248                         for _, k2 := range v2 {
12249                                 ee.WriteMapElemKey()
12250                                 ee.EncodeInt(int64(int16(k2)))
12251                                 ee.WriteMapElemValue()
12252                                 ee.EncodeInt(int64(v[int16(k2)]))
12253                         }
12254                 } else {
12255                         for _, k2 := range v2 {
12256                                 ee.EncodeInt(int64(int16(k2)))
12257                                 ee.EncodeInt(int64(v[int16(k2)]))
12258                         }
12259                 }
12260         } else {
12261                 if esep {
12262                         for k2, v2 := range v {
12263                                 ee.WriteMapElemKey()
12264                                 ee.EncodeInt(int64(k2))
12265                                 ee.WriteMapElemValue()
12266                                 ee.EncodeInt(int64(v2))
12267                         }
12268                 } else {
12269                         for k2, v2 := range v {
12270                                 ee.EncodeInt(int64(k2))
12271                                 ee.EncodeInt(int64(v2))
12272                         }
12273                 }
12274         }
12275         ee.WriteMapEnd()
12276 }
12277
12278 func (e *Encoder) fastpathEncMapInt16Int16R(f *codecFnInfo, rv reflect.Value) {
12279         fastpathTV.EncMapInt16Int16V(rv2i(rv).(map[int16]int16), e)
12280 }
12281 func (_ fastpathT) EncMapInt16Int16V(v map[int16]int16, e *Encoder) {
12282         if v == nil {
12283                 e.e.EncodeNil()
12284                 return
12285         }
12286         ee, esep := e.e, e.hh.hasElemSeparators()
12287         ee.WriteMapStart(len(v))
12288         if e.h.Canonical {
12289                 v2 := make([]int64, len(v))
12290                 var i int
12291                 for k, _ := range v {
12292                         v2[i] = int64(k)
12293                         i++
12294                 }
12295                 sort.Sort(intSlice(v2))
12296                 if esep {
12297                         for _, k2 := range v2 {
12298                                 ee.WriteMapElemKey()
12299                                 ee.EncodeInt(int64(int16(k2)))
12300                                 ee.WriteMapElemValue()
12301                                 ee.EncodeInt(int64(v[int16(k2)]))
12302                         }
12303                 } else {
12304                         for _, k2 := range v2 {
12305                                 ee.EncodeInt(int64(int16(k2)))
12306                                 ee.EncodeInt(int64(v[int16(k2)]))
12307                         }
12308                 }
12309         } else {
12310                 if esep {
12311                         for k2, v2 := range v {
12312                                 ee.WriteMapElemKey()
12313                                 ee.EncodeInt(int64(k2))
12314                                 ee.WriteMapElemValue()
12315                                 ee.EncodeInt(int64(v2))
12316                         }
12317                 } else {
12318                         for k2, v2 := range v {
12319                                 ee.EncodeInt(int64(k2))
12320                                 ee.EncodeInt(int64(v2))
12321                         }
12322                 }
12323         }
12324         ee.WriteMapEnd()
12325 }
12326
12327 func (e *Encoder) fastpathEncMapInt16Int32R(f *codecFnInfo, rv reflect.Value) {
12328         fastpathTV.EncMapInt16Int32V(rv2i(rv).(map[int16]int32), e)
12329 }
12330 func (_ fastpathT) EncMapInt16Int32V(v map[int16]int32, e *Encoder) {
12331         if v == nil {
12332                 e.e.EncodeNil()
12333                 return
12334         }
12335         ee, esep := e.e, e.hh.hasElemSeparators()
12336         ee.WriteMapStart(len(v))
12337         if e.h.Canonical {
12338                 v2 := make([]int64, len(v))
12339                 var i int
12340                 for k, _ := range v {
12341                         v2[i] = int64(k)
12342                         i++
12343                 }
12344                 sort.Sort(intSlice(v2))
12345                 if esep {
12346                         for _, k2 := range v2 {
12347                                 ee.WriteMapElemKey()
12348                                 ee.EncodeInt(int64(int16(k2)))
12349                                 ee.WriteMapElemValue()
12350                                 ee.EncodeInt(int64(v[int16(k2)]))
12351                         }
12352                 } else {
12353                         for _, k2 := range v2 {
12354                                 ee.EncodeInt(int64(int16(k2)))
12355                                 ee.EncodeInt(int64(v[int16(k2)]))
12356                         }
12357                 }
12358         } else {
12359                 if esep {
12360                         for k2, v2 := range v {
12361                                 ee.WriteMapElemKey()
12362                                 ee.EncodeInt(int64(k2))
12363                                 ee.WriteMapElemValue()
12364                                 ee.EncodeInt(int64(v2))
12365                         }
12366                 } else {
12367                         for k2, v2 := range v {
12368                                 ee.EncodeInt(int64(k2))
12369                                 ee.EncodeInt(int64(v2))
12370                         }
12371                 }
12372         }
12373         ee.WriteMapEnd()
12374 }
12375
12376 func (e *Encoder) fastpathEncMapInt16Int64R(f *codecFnInfo, rv reflect.Value) {
12377         fastpathTV.EncMapInt16Int64V(rv2i(rv).(map[int16]int64), e)
12378 }
12379 func (_ fastpathT) EncMapInt16Int64V(v map[int16]int64, e *Encoder) {
12380         if v == nil {
12381                 e.e.EncodeNil()
12382                 return
12383         }
12384         ee, esep := e.e, e.hh.hasElemSeparators()
12385         ee.WriteMapStart(len(v))
12386         if e.h.Canonical {
12387                 v2 := make([]int64, len(v))
12388                 var i int
12389                 for k, _ := range v {
12390                         v2[i] = int64(k)
12391                         i++
12392                 }
12393                 sort.Sort(intSlice(v2))
12394                 if esep {
12395                         for _, k2 := range v2 {
12396                                 ee.WriteMapElemKey()
12397                                 ee.EncodeInt(int64(int16(k2)))
12398                                 ee.WriteMapElemValue()
12399                                 ee.EncodeInt(int64(v[int16(k2)]))
12400                         }
12401                 } else {
12402                         for _, k2 := range v2 {
12403                                 ee.EncodeInt(int64(int16(k2)))
12404                                 ee.EncodeInt(int64(v[int16(k2)]))
12405                         }
12406                 }
12407         } else {
12408                 if esep {
12409                         for k2, v2 := range v {
12410                                 ee.WriteMapElemKey()
12411                                 ee.EncodeInt(int64(k2))
12412                                 ee.WriteMapElemValue()
12413                                 ee.EncodeInt(int64(v2))
12414                         }
12415                 } else {
12416                         for k2, v2 := range v {
12417                                 ee.EncodeInt(int64(k2))
12418                                 ee.EncodeInt(int64(v2))
12419                         }
12420                 }
12421         }
12422         ee.WriteMapEnd()
12423 }
12424
12425 func (e *Encoder) fastpathEncMapInt16Float32R(f *codecFnInfo, rv reflect.Value) {
12426         fastpathTV.EncMapInt16Float32V(rv2i(rv).(map[int16]float32), e)
12427 }
12428 func (_ fastpathT) EncMapInt16Float32V(v map[int16]float32, e *Encoder) {
12429         if v == nil {
12430                 e.e.EncodeNil()
12431                 return
12432         }
12433         ee, esep := e.e, e.hh.hasElemSeparators()
12434         ee.WriteMapStart(len(v))
12435         if e.h.Canonical {
12436                 v2 := make([]int64, len(v))
12437                 var i int
12438                 for k, _ := range v {
12439                         v2[i] = int64(k)
12440                         i++
12441                 }
12442                 sort.Sort(intSlice(v2))
12443                 if esep {
12444                         for _, k2 := range v2 {
12445                                 ee.WriteMapElemKey()
12446                                 ee.EncodeInt(int64(int16(k2)))
12447                                 ee.WriteMapElemValue()
12448                                 ee.EncodeFloat32(v[int16(k2)])
12449                         }
12450                 } else {
12451                         for _, k2 := range v2 {
12452                                 ee.EncodeInt(int64(int16(k2)))
12453                                 ee.EncodeFloat32(v[int16(k2)])
12454                         }
12455                 }
12456         } else {
12457                 if esep {
12458                         for k2, v2 := range v {
12459                                 ee.WriteMapElemKey()
12460                                 ee.EncodeInt(int64(k2))
12461                                 ee.WriteMapElemValue()
12462                                 ee.EncodeFloat32(v2)
12463                         }
12464                 } else {
12465                         for k2, v2 := range v {
12466                                 ee.EncodeInt(int64(k2))
12467                                 ee.EncodeFloat32(v2)
12468                         }
12469                 }
12470         }
12471         ee.WriteMapEnd()
12472 }
12473
12474 func (e *Encoder) fastpathEncMapInt16Float64R(f *codecFnInfo, rv reflect.Value) {
12475         fastpathTV.EncMapInt16Float64V(rv2i(rv).(map[int16]float64), e)
12476 }
12477 func (_ fastpathT) EncMapInt16Float64V(v map[int16]float64, e *Encoder) {
12478         if v == nil {
12479                 e.e.EncodeNil()
12480                 return
12481         }
12482         ee, esep := e.e, e.hh.hasElemSeparators()
12483         ee.WriteMapStart(len(v))
12484         if e.h.Canonical {
12485                 v2 := make([]int64, len(v))
12486                 var i int
12487                 for k, _ := range v {
12488                         v2[i] = int64(k)
12489                         i++
12490                 }
12491                 sort.Sort(intSlice(v2))
12492                 if esep {
12493                         for _, k2 := range v2 {
12494                                 ee.WriteMapElemKey()
12495                                 ee.EncodeInt(int64(int16(k2)))
12496                                 ee.WriteMapElemValue()
12497                                 ee.EncodeFloat64(v[int16(k2)])
12498                         }
12499                 } else {
12500                         for _, k2 := range v2 {
12501                                 ee.EncodeInt(int64(int16(k2)))
12502                                 ee.EncodeFloat64(v[int16(k2)])
12503                         }
12504                 }
12505         } else {
12506                 if esep {
12507                         for k2, v2 := range v {
12508                                 ee.WriteMapElemKey()
12509                                 ee.EncodeInt(int64(k2))
12510                                 ee.WriteMapElemValue()
12511                                 ee.EncodeFloat64(v2)
12512                         }
12513                 } else {
12514                         for k2, v2 := range v {
12515                                 ee.EncodeInt(int64(k2))
12516                                 ee.EncodeFloat64(v2)
12517                         }
12518                 }
12519         }
12520         ee.WriteMapEnd()
12521 }
12522
12523 func (e *Encoder) fastpathEncMapInt16BoolR(f *codecFnInfo, rv reflect.Value) {
12524         fastpathTV.EncMapInt16BoolV(rv2i(rv).(map[int16]bool), e)
12525 }
12526 func (_ fastpathT) EncMapInt16BoolV(v map[int16]bool, e *Encoder) {
12527         if v == nil {
12528                 e.e.EncodeNil()
12529                 return
12530         }
12531         ee, esep := e.e, e.hh.hasElemSeparators()
12532         ee.WriteMapStart(len(v))
12533         if e.h.Canonical {
12534                 v2 := make([]int64, len(v))
12535                 var i int
12536                 for k, _ := range v {
12537                         v2[i] = int64(k)
12538                         i++
12539                 }
12540                 sort.Sort(intSlice(v2))
12541                 if esep {
12542                         for _, k2 := range v2 {
12543                                 ee.WriteMapElemKey()
12544                                 ee.EncodeInt(int64(int16(k2)))
12545                                 ee.WriteMapElemValue()
12546                                 ee.EncodeBool(v[int16(k2)])
12547                         }
12548                 } else {
12549                         for _, k2 := range v2 {
12550                                 ee.EncodeInt(int64(int16(k2)))
12551                                 ee.EncodeBool(v[int16(k2)])
12552                         }
12553                 }
12554         } else {
12555                 if esep {
12556                         for k2, v2 := range v {
12557                                 ee.WriteMapElemKey()
12558                                 ee.EncodeInt(int64(k2))
12559                                 ee.WriteMapElemValue()
12560                                 ee.EncodeBool(v2)
12561                         }
12562                 } else {
12563                         for k2, v2 := range v {
12564                                 ee.EncodeInt(int64(k2))
12565                                 ee.EncodeBool(v2)
12566                         }
12567                 }
12568         }
12569         ee.WriteMapEnd()
12570 }
12571
12572 func (e *Encoder) fastpathEncMapInt32IntfR(f *codecFnInfo, rv reflect.Value) {
12573         fastpathTV.EncMapInt32IntfV(rv2i(rv).(map[int32]interface{}), e)
12574 }
12575 func (_ fastpathT) EncMapInt32IntfV(v map[int32]interface{}, e *Encoder) {
12576         if v == nil {
12577                 e.e.EncodeNil()
12578                 return
12579         }
12580         ee, esep := e.e, e.hh.hasElemSeparators()
12581         ee.WriteMapStart(len(v))
12582         if e.h.Canonical {
12583                 v2 := make([]int64, len(v))
12584                 var i int
12585                 for k, _ := range v {
12586                         v2[i] = int64(k)
12587                         i++
12588                 }
12589                 sort.Sort(intSlice(v2))
12590                 if esep {
12591                         for _, k2 := range v2 {
12592                                 ee.WriteMapElemKey()
12593                                 ee.EncodeInt(int64(int32(k2)))
12594                                 ee.WriteMapElemValue()
12595                                 e.encode(v[int32(k2)])
12596                         }
12597                 } else {
12598                         for _, k2 := range v2 {
12599                                 ee.EncodeInt(int64(int32(k2)))
12600                                 e.encode(v[int32(k2)])
12601                         }
12602                 }
12603         } else {
12604                 if esep {
12605                         for k2, v2 := range v {
12606                                 ee.WriteMapElemKey()
12607                                 ee.EncodeInt(int64(k2))
12608                                 ee.WriteMapElemValue()
12609                                 e.encode(v2)
12610                         }
12611                 } else {
12612                         for k2, v2 := range v {
12613                                 ee.EncodeInt(int64(k2))
12614                                 e.encode(v2)
12615                         }
12616                 }
12617         }
12618         ee.WriteMapEnd()
12619 }
12620
12621 func (e *Encoder) fastpathEncMapInt32StringR(f *codecFnInfo, rv reflect.Value) {
12622         fastpathTV.EncMapInt32StringV(rv2i(rv).(map[int32]string), e)
12623 }
12624 func (_ fastpathT) EncMapInt32StringV(v map[int32]string, e *Encoder) {
12625         if v == nil {
12626                 e.e.EncodeNil()
12627                 return
12628         }
12629         ee, esep := e.e, e.hh.hasElemSeparators()
12630         ee.WriteMapStart(len(v))
12631         if e.h.Canonical {
12632                 v2 := make([]int64, len(v))
12633                 var i int
12634                 for k, _ := range v {
12635                         v2[i] = int64(k)
12636                         i++
12637                 }
12638                 sort.Sort(intSlice(v2))
12639                 if esep {
12640                         for _, k2 := range v2 {
12641                                 ee.WriteMapElemKey()
12642                                 ee.EncodeInt(int64(int32(k2)))
12643                                 ee.WriteMapElemValue()
12644                                 ee.EncodeString(cUTF8, v[int32(k2)])
12645                         }
12646                 } else {
12647                         for _, k2 := range v2 {
12648                                 ee.EncodeInt(int64(int32(k2)))
12649                                 ee.EncodeString(cUTF8, v[int32(k2)])
12650                         }
12651                 }
12652         } else {
12653                 if esep {
12654                         for k2, v2 := range v {
12655                                 ee.WriteMapElemKey()
12656                                 ee.EncodeInt(int64(k2))
12657                                 ee.WriteMapElemValue()
12658                                 ee.EncodeString(cUTF8, v2)
12659                         }
12660                 } else {
12661                         for k2, v2 := range v {
12662                                 ee.EncodeInt(int64(k2))
12663                                 ee.EncodeString(cUTF8, v2)
12664                         }
12665                 }
12666         }
12667         ee.WriteMapEnd()
12668 }
12669
12670 func (e *Encoder) fastpathEncMapInt32UintR(f *codecFnInfo, rv reflect.Value) {
12671         fastpathTV.EncMapInt32UintV(rv2i(rv).(map[int32]uint), e)
12672 }
12673 func (_ fastpathT) EncMapInt32UintV(v map[int32]uint, e *Encoder) {
12674         if v == nil {
12675                 e.e.EncodeNil()
12676                 return
12677         }
12678         ee, esep := e.e, e.hh.hasElemSeparators()
12679         ee.WriteMapStart(len(v))
12680         if e.h.Canonical {
12681                 v2 := make([]int64, len(v))
12682                 var i int
12683                 for k, _ := range v {
12684                         v2[i] = int64(k)
12685                         i++
12686                 }
12687                 sort.Sort(intSlice(v2))
12688                 if esep {
12689                         for _, k2 := range v2 {
12690                                 ee.WriteMapElemKey()
12691                                 ee.EncodeInt(int64(int32(k2)))
12692                                 ee.WriteMapElemValue()
12693                                 ee.EncodeUint(uint64(v[int32(k2)]))
12694                         }
12695                 } else {
12696                         for _, k2 := range v2 {
12697                                 ee.EncodeInt(int64(int32(k2)))
12698                                 ee.EncodeUint(uint64(v[int32(k2)]))
12699                         }
12700                 }
12701         } else {
12702                 if esep {
12703                         for k2, v2 := range v {
12704                                 ee.WriteMapElemKey()
12705                                 ee.EncodeInt(int64(k2))
12706                                 ee.WriteMapElemValue()
12707                                 ee.EncodeUint(uint64(v2))
12708                         }
12709                 } else {
12710                         for k2, v2 := range v {
12711                                 ee.EncodeInt(int64(k2))
12712                                 ee.EncodeUint(uint64(v2))
12713                         }
12714                 }
12715         }
12716         ee.WriteMapEnd()
12717 }
12718
12719 func (e *Encoder) fastpathEncMapInt32Uint8R(f *codecFnInfo, rv reflect.Value) {
12720         fastpathTV.EncMapInt32Uint8V(rv2i(rv).(map[int32]uint8), e)
12721 }
12722 func (_ fastpathT) EncMapInt32Uint8V(v map[int32]uint8, e *Encoder) {
12723         if v == nil {
12724                 e.e.EncodeNil()
12725                 return
12726         }
12727         ee, esep := e.e, e.hh.hasElemSeparators()
12728         ee.WriteMapStart(len(v))
12729         if e.h.Canonical {
12730                 v2 := make([]int64, len(v))
12731                 var i int
12732                 for k, _ := range v {
12733                         v2[i] = int64(k)
12734                         i++
12735                 }
12736                 sort.Sort(intSlice(v2))
12737                 if esep {
12738                         for _, k2 := range v2 {
12739                                 ee.WriteMapElemKey()
12740                                 ee.EncodeInt(int64(int32(k2)))
12741                                 ee.WriteMapElemValue()
12742                                 ee.EncodeUint(uint64(v[int32(k2)]))
12743                         }
12744                 } else {
12745                         for _, k2 := range v2 {
12746                                 ee.EncodeInt(int64(int32(k2)))
12747                                 ee.EncodeUint(uint64(v[int32(k2)]))
12748                         }
12749                 }
12750         } else {
12751                 if esep {
12752                         for k2, v2 := range v {
12753                                 ee.WriteMapElemKey()
12754                                 ee.EncodeInt(int64(k2))
12755                                 ee.WriteMapElemValue()
12756                                 ee.EncodeUint(uint64(v2))
12757                         }
12758                 } else {
12759                         for k2, v2 := range v {
12760                                 ee.EncodeInt(int64(k2))
12761                                 ee.EncodeUint(uint64(v2))
12762                         }
12763                 }
12764         }
12765         ee.WriteMapEnd()
12766 }
12767
12768 func (e *Encoder) fastpathEncMapInt32Uint16R(f *codecFnInfo, rv reflect.Value) {
12769         fastpathTV.EncMapInt32Uint16V(rv2i(rv).(map[int32]uint16), e)
12770 }
12771 func (_ fastpathT) EncMapInt32Uint16V(v map[int32]uint16, e *Encoder) {
12772         if v == nil {
12773                 e.e.EncodeNil()
12774                 return
12775         }
12776         ee, esep := e.e, e.hh.hasElemSeparators()
12777         ee.WriteMapStart(len(v))
12778         if e.h.Canonical {
12779                 v2 := make([]int64, len(v))
12780                 var i int
12781                 for k, _ := range v {
12782                         v2[i] = int64(k)
12783                         i++
12784                 }
12785                 sort.Sort(intSlice(v2))
12786                 if esep {
12787                         for _, k2 := range v2 {
12788                                 ee.WriteMapElemKey()
12789                                 ee.EncodeInt(int64(int32(k2)))
12790                                 ee.WriteMapElemValue()
12791                                 ee.EncodeUint(uint64(v[int32(k2)]))
12792                         }
12793                 } else {
12794                         for _, k2 := range v2 {
12795                                 ee.EncodeInt(int64(int32(k2)))
12796                                 ee.EncodeUint(uint64(v[int32(k2)]))
12797                         }
12798                 }
12799         } else {
12800                 if esep {
12801                         for k2, v2 := range v {
12802                                 ee.WriteMapElemKey()
12803                                 ee.EncodeInt(int64(k2))
12804                                 ee.WriteMapElemValue()
12805                                 ee.EncodeUint(uint64(v2))
12806                         }
12807                 } else {
12808                         for k2, v2 := range v {
12809                                 ee.EncodeInt(int64(k2))
12810                                 ee.EncodeUint(uint64(v2))
12811                         }
12812                 }
12813         }
12814         ee.WriteMapEnd()
12815 }
12816
12817 func (e *Encoder) fastpathEncMapInt32Uint32R(f *codecFnInfo, rv reflect.Value) {
12818         fastpathTV.EncMapInt32Uint32V(rv2i(rv).(map[int32]uint32), e)
12819 }
12820 func (_ fastpathT) EncMapInt32Uint32V(v map[int32]uint32, e *Encoder) {
12821         if v == nil {
12822                 e.e.EncodeNil()
12823                 return
12824         }
12825         ee, esep := e.e, e.hh.hasElemSeparators()
12826         ee.WriteMapStart(len(v))
12827         if e.h.Canonical {
12828                 v2 := make([]int64, len(v))
12829                 var i int
12830                 for k, _ := range v {
12831                         v2[i] = int64(k)
12832                         i++
12833                 }
12834                 sort.Sort(intSlice(v2))
12835                 if esep {
12836                         for _, k2 := range v2 {
12837                                 ee.WriteMapElemKey()
12838                                 ee.EncodeInt(int64(int32(k2)))
12839                                 ee.WriteMapElemValue()
12840                                 ee.EncodeUint(uint64(v[int32(k2)]))
12841                         }
12842                 } else {
12843                         for _, k2 := range v2 {
12844                                 ee.EncodeInt(int64(int32(k2)))
12845                                 ee.EncodeUint(uint64(v[int32(k2)]))
12846                         }
12847                 }
12848         } else {
12849                 if esep {
12850                         for k2, v2 := range v {
12851                                 ee.WriteMapElemKey()
12852                                 ee.EncodeInt(int64(k2))
12853                                 ee.WriteMapElemValue()
12854                                 ee.EncodeUint(uint64(v2))
12855                         }
12856                 } else {
12857                         for k2, v2 := range v {
12858                                 ee.EncodeInt(int64(k2))
12859                                 ee.EncodeUint(uint64(v2))
12860                         }
12861                 }
12862         }
12863         ee.WriteMapEnd()
12864 }
12865
12866 func (e *Encoder) fastpathEncMapInt32Uint64R(f *codecFnInfo, rv reflect.Value) {
12867         fastpathTV.EncMapInt32Uint64V(rv2i(rv).(map[int32]uint64), e)
12868 }
12869 func (_ fastpathT) EncMapInt32Uint64V(v map[int32]uint64, e *Encoder) {
12870         if v == nil {
12871                 e.e.EncodeNil()
12872                 return
12873         }
12874         ee, esep := e.e, e.hh.hasElemSeparators()
12875         ee.WriteMapStart(len(v))
12876         if e.h.Canonical {
12877                 v2 := make([]int64, len(v))
12878                 var i int
12879                 for k, _ := range v {
12880                         v2[i] = int64(k)
12881                         i++
12882                 }
12883                 sort.Sort(intSlice(v2))
12884                 if esep {
12885                         for _, k2 := range v2 {
12886                                 ee.WriteMapElemKey()
12887                                 ee.EncodeInt(int64(int32(k2)))
12888                                 ee.WriteMapElemValue()
12889                                 ee.EncodeUint(uint64(v[int32(k2)]))
12890                         }
12891                 } else {
12892                         for _, k2 := range v2 {
12893                                 ee.EncodeInt(int64(int32(k2)))
12894                                 ee.EncodeUint(uint64(v[int32(k2)]))
12895                         }
12896                 }
12897         } else {
12898                 if esep {
12899                         for k2, v2 := range v {
12900                                 ee.WriteMapElemKey()
12901                                 ee.EncodeInt(int64(k2))
12902                                 ee.WriteMapElemValue()
12903                                 ee.EncodeUint(uint64(v2))
12904                         }
12905                 } else {
12906                         for k2, v2 := range v {
12907                                 ee.EncodeInt(int64(k2))
12908                                 ee.EncodeUint(uint64(v2))
12909                         }
12910                 }
12911         }
12912         ee.WriteMapEnd()
12913 }
12914
12915 func (e *Encoder) fastpathEncMapInt32UintptrR(f *codecFnInfo, rv reflect.Value) {
12916         fastpathTV.EncMapInt32UintptrV(rv2i(rv).(map[int32]uintptr), e)
12917 }
12918 func (_ fastpathT) EncMapInt32UintptrV(v map[int32]uintptr, e *Encoder) {
12919         if v == nil {
12920                 e.e.EncodeNil()
12921                 return
12922         }
12923         ee, esep := e.e, e.hh.hasElemSeparators()
12924         ee.WriteMapStart(len(v))
12925         if e.h.Canonical {
12926                 v2 := make([]int64, len(v))
12927                 var i int
12928                 for k, _ := range v {
12929                         v2[i] = int64(k)
12930                         i++
12931                 }
12932                 sort.Sort(intSlice(v2))
12933                 if esep {
12934                         for _, k2 := range v2 {
12935                                 ee.WriteMapElemKey()
12936                                 ee.EncodeInt(int64(int32(k2)))
12937                                 ee.WriteMapElemValue()
12938                                 e.encode(v[int32(k2)])
12939                         }
12940                 } else {
12941                         for _, k2 := range v2 {
12942                                 ee.EncodeInt(int64(int32(k2)))
12943                                 e.encode(v[int32(k2)])
12944                         }
12945                 }
12946         } else {
12947                 if esep {
12948                         for k2, v2 := range v {
12949                                 ee.WriteMapElemKey()
12950                                 ee.EncodeInt(int64(k2))
12951                                 ee.WriteMapElemValue()
12952                                 e.encode(v2)
12953                         }
12954                 } else {
12955                         for k2, v2 := range v {
12956                                 ee.EncodeInt(int64(k2))
12957                                 e.encode(v2)
12958                         }
12959                 }
12960         }
12961         ee.WriteMapEnd()
12962 }
12963
12964 func (e *Encoder) fastpathEncMapInt32IntR(f *codecFnInfo, rv reflect.Value) {
12965         fastpathTV.EncMapInt32IntV(rv2i(rv).(map[int32]int), e)
12966 }
12967 func (_ fastpathT) EncMapInt32IntV(v map[int32]int, e *Encoder) {
12968         if v == nil {
12969                 e.e.EncodeNil()
12970                 return
12971         }
12972         ee, esep := e.e, e.hh.hasElemSeparators()
12973         ee.WriteMapStart(len(v))
12974         if e.h.Canonical {
12975                 v2 := make([]int64, len(v))
12976                 var i int
12977                 for k, _ := range v {
12978                         v2[i] = int64(k)
12979                         i++
12980                 }
12981                 sort.Sort(intSlice(v2))
12982                 if esep {
12983                         for _, k2 := range v2 {
12984                                 ee.WriteMapElemKey()
12985                                 ee.EncodeInt(int64(int32(k2)))
12986                                 ee.WriteMapElemValue()
12987                                 ee.EncodeInt(int64(v[int32(k2)]))
12988                         }
12989                 } else {
12990                         for _, k2 := range v2 {
12991                                 ee.EncodeInt(int64(int32(k2)))
12992                                 ee.EncodeInt(int64(v[int32(k2)]))
12993                         }
12994                 }
12995         } else {
12996                 if esep {
12997                         for k2, v2 := range v {
12998                                 ee.WriteMapElemKey()
12999                                 ee.EncodeInt(int64(k2))
13000                                 ee.WriteMapElemValue()
13001                                 ee.EncodeInt(int64(v2))
13002                         }
13003                 } else {
13004                         for k2, v2 := range v {
13005                                 ee.EncodeInt(int64(k2))
13006                                 ee.EncodeInt(int64(v2))
13007                         }
13008                 }
13009         }
13010         ee.WriteMapEnd()
13011 }
13012
13013 func (e *Encoder) fastpathEncMapInt32Int8R(f *codecFnInfo, rv reflect.Value) {
13014         fastpathTV.EncMapInt32Int8V(rv2i(rv).(map[int32]int8), e)
13015 }
13016 func (_ fastpathT) EncMapInt32Int8V(v map[int32]int8, e *Encoder) {
13017         if v == nil {
13018                 e.e.EncodeNil()
13019                 return
13020         }
13021         ee, esep := e.e, e.hh.hasElemSeparators()
13022         ee.WriteMapStart(len(v))
13023         if e.h.Canonical {
13024                 v2 := make([]int64, len(v))
13025                 var i int
13026                 for k, _ := range v {
13027                         v2[i] = int64(k)
13028                         i++
13029                 }
13030                 sort.Sort(intSlice(v2))
13031                 if esep {
13032                         for _, k2 := range v2 {
13033                                 ee.WriteMapElemKey()
13034                                 ee.EncodeInt(int64(int32(k2)))
13035                                 ee.WriteMapElemValue()
13036                                 ee.EncodeInt(int64(v[int32(k2)]))
13037                         }
13038                 } else {
13039                         for _, k2 := range v2 {
13040                                 ee.EncodeInt(int64(int32(k2)))
13041                                 ee.EncodeInt(int64(v[int32(k2)]))
13042                         }
13043                 }
13044         } else {
13045                 if esep {
13046                         for k2, v2 := range v {
13047                                 ee.WriteMapElemKey()
13048                                 ee.EncodeInt(int64(k2))
13049                                 ee.WriteMapElemValue()
13050                                 ee.EncodeInt(int64(v2))
13051                         }
13052                 } else {
13053                         for k2, v2 := range v {
13054                                 ee.EncodeInt(int64(k2))
13055                                 ee.EncodeInt(int64(v2))
13056                         }
13057                 }
13058         }
13059         ee.WriteMapEnd()
13060 }
13061
13062 func (e *Encoder) fastpathEncMapInt32Int16R(f *codecFnInfo, rv reflect.Value) {
13063         fastpathTV.EncMapInt32Int16V(rv2i(rv).(map[int32]int16), e)
13064 }
13065 func (_ fastpathT) EncMapInt32Int16V(v map[int32]int16, e *Encoder) {
13066         if v == nil {
13067                 e.e.EncodeNil()
13068                 return
13069         }
13070         ee, esep := e.e, e.hh.hasElemSeparators()
13071         ee.WriteMapStart(len(v))
13072         if e.h.Canonical {
13073                 v2 := make([]int64, len(v))
13074                 var i int
13075                 for k, _ := range v {
13076                         v2[i] = int64(k)
13077                         i++
13078                 }
13079                 sort.Sort(intSlice(v2))
13080                 if esep {
13081                         for _, k2 := range v2 {
13082                                 ee.WriteMapElemKey()
13083                                 ee.EncodeInt(int64(int32(k2)))
13084                                 ee.WriteMapElemValue()
13085                                 ee.EncodeInt(int64(v[int32(k2)]))
13086                         }
13087                 } else {
13088                         for _, k2 := range v2 {
13089                                 ee.EncodeInt(int64(int32(k2)))
13090                                 ee.EncodeInt(int64(v[int32(k2)]))
13091                         }
13092                 }
13093         } else {
13094                 if esep {
13095                         for k2, v2 := range v {
13096                                 ee.WriteMapElemKey()
13097                                 ee.EncodeInt(int64(k2))
13098                                 ee.WriteMapElemValue()
13099                                 ee.EncodeInt(int64(v2))
13100                         }
13101                 } else {
13102                         for k2, v2 := range v {
13103                                 ee.EncodeInt(int64(k2))
13104                                 ee.EncodeInt(int64(v2))
13105                         }
13106                 }
13107         }
13108         ee.WriteMapEnd()
13109 }
13110
13111 func (e *Encoder) fastpathEncMapInt32Int32R(f *codecFnInfo, rv reflect.Value) {
13112         fastpathTV.EncMapInt32Int32V(rv2i(rv).(map[int32]int32), e)
13113 }
13114 func (_ fastpathT) EncMapInt32Int32V(v map[int32]int32, e *Encoder) {
13115         if v == nil {
13116                 e.e.EncodeNil()
13117                 return
13118         }
13119         ee, esep := e.e, e.hh.hasElemSeparators()
13120         ee.WriteMapStart(len(v))
13121         if e.h.Canonical {
13122                 v2 := make([]int64, len(v))
13123                 var i int
13124                 for k, _ := range v {
13125                         v2[i] = int64(k)
13126                         i++
13127                 }
13128                 sort.Sort(intSlice(v2))
13129                 if esep {
13130                         for _, k2 := range v2 {
13131                                 ee.WriteMapElemKey()
13132                                 ee.EncodeInt(int64(int32(k2)))
13133                                 ee.WriteMapElemValue()
13134                                 ee.EncodeInt(int64(v[int32(k2)]))
13135                         }
13136                 } else {
13137                         for _, k2 := range v2 {
13138                                 ee.EncodeInt(int64(int32(k2)))
13139                                 ee.EncodeInt(int64(v[int32(k2)]))
13140                         }
13141                 }
13142         } else {
13143                 if esep {
13144                         for k2, v2 := range v {
13145                                 ee.WriteMapElemKey()
13146                                 ee.EncodeInt(int64(k2))
13147                                 ee.WriteMapElemValue()
13148                                 ee.EncodeInt(int64(v2))
13149                         }
13150                 } else {
13151                         for k2, v2 := range v {
13152                                 ee.EncodeInt(int64(k2))
13153                                 ee.EncodeInt(int64(v2))
13154                         }
13155                 }
13156         }
13157         ee.WriteMapEnd()
13158 }
13159
13160 func (e *Encoder) fastpathEncMapInt32Int64R(f *codecFnInfo, rv reflect.Value) {
13161         fastpathTV.EncMapInt32Int64V(rv2i(rv).(map[int32]int64), e)
13162 }
13163 func (_ fastpathT) EncMapInt32Int64V(v map[int32]int64, e *Encoder) {
13164         if v == nil {
13165                 e.e.EncodeNil()
13166                 return
13167         }
13168         ee, esep := e.e, e.hh.hasElemSeparators()
13169         ee.WriteMapStart(len(v))
13170         if e.h.Canonical {
13171                 v2 := make([]int64, len(v))
13172                 var i int
13173                 for k, _ := range v {
13174                         v2[i] = int64(k)
13175                         i++
13176                 }
13177                 sort.Sort(intSlice(v2))
13178                 if esep {
13179                         for _, k2 := range v2 {
13180                                 ee.WriteMapElemKey()
13181                                 ee.EncodeInt(int64(int32(k2)))
13182                                 ee.WriteMapElemValue()
13183                                 ee.EncodeInt(int64(v[int32(k2)]))
13184                         }
13185                 } else {
13186                         for _, k2 := range v2 {
13187                                 ee.EncodeInt(int64(int32(k2)))
13188                                 ee.EncodeInt(int64(v[int32(k2)]))
13189                         }
13190                 }
13191         } else {
13192                 if esep {
13193                         for k2, v2 := range v {
13194                                 ee.WriteMapElemKey()
13195                                 ee.EncodeInt(int64(k2))
13196                                 ee.WriteMapElemValue()
13197                                 ee.EncodeInt(int64(v2))
13198                         }
13199                 } else {
13200                         for k2, v2 := range v {
13201                                 ee.EncodeInt(int64(k2))
13202                                 ee.EncodeInt(int64(v2))
13203                         }
13204                 }
13205         }
13206         ee.WriteMapEnd()
13207 }
13208
13209 func (e *Encoder) fastpathEncMapInt32Float32R(f *codecFnInfo, rv reflect.Value) {
13210         fastpathTV.EncMapInt32Float32V(rv2i(rv).(map[int32]float32), e)
13211 }
13212 func (_ fastpathT) EncMapInt32Float32V(v map[int32]float32, e *Encoder) {
13213         if v == nil {
13214                 e.e.EncodeNil()
13215                 return
13216         }
13217         ee, esep := e.e, e.hh.hasElemSeparators()
13218         ee.WriteMapStart(len(v))
13219         if e.h.Canonical {
13220                 v2 := make([]int64, len(v))
13221                 var i int
13222                 for k, _ := range v {
13223                         v2[i] = int64(k)
13224                         i++
13225                 }
13226                 sort.Sort(intSlice(v2))
13227                 if esep {
13228                         for _, k2 := range v2 {
13229                                 ee.WriteMapElemKey()
13230                                 ee.EncodeInt(int64(int32(k2)))
13231                                 ee.WriteMapElemValue()
13232                                 ee.EncodeFloat32(v[int32(k2)])
13233                         }
13234                 } else {
13235                         for _, k2 := range v2 {
13236                                 ee.EncodeInt(int64(int32(k2)))
13237                                 ee.EncodeFloat32(v[int32(k2)])
13238                         }
13239                 }
13240         } else {
13241                 if esep {
13242                         for k2, v2 := range v {
13243                                 ee.WriteMapElemKey()
13244                                 ee.EncodeInt(int64(k2))
13245                                 ee.WriteMapElemValue()
13246                                 ee.EncodeFloat32(v2)
13247                         }
13248                 } else {
13249                         for k2, v2 := range v {
13250                                 ee.EncodeInt(int64(k2))
13251                                 ee.EncodeFloat32(v2)
13252                         }
13253                 }
13254         }
13255         ee.WriteMapEnd()
13256 }
13257
13258 func (e *Encoder) fastpathEncMapInt32Float64R(f *codecFnInfo, rv reflect.Value) {
13259         fastpathTV.EncMapInt32Float64V(rv2i(rv).(map[int32]float64), e)
13260 }
13261 func (_ fastpathT) EncMapInt32Float64V(v map[int32]float64, e *Encoder) {
13262         if v == nil {
13263                 e.e.EncodeNil()
13264                 return
13265         }
13266         ee, esep := e.e, e.hh.hasElemSeparators()
13267         ee.WriteMapStart(len(v))
13268         if e.h.Canonical {
13269                 v2 := make([]int64, len(v))
13270                 var i int
13271                 for k, _ := range v {
13272                         v2[i] = int64(k)
13273                         i++
13274                 }
13275                 sort.Sort(intSlice(v2))
13276                 if esep {
13277                         for _, k2 := range v2 {
13278                                 ee.WriteMapElemKey()
13279                                 ee.EncodeInt(int64(int32(k2)))
13280                                 ee.WriteMapElemValue()
13281                                 ee.EncodeFloat64(v[int32(k2)])
13282                         }
13283                 } else {
13284                         for _, k2 := range v2 {
13285                                 ee.EncodeInt(int64(int32(k2)))
13286                                 ee.EncodeFloat64(v[int32(k2)])
13287                         }
13288                 }
13289         } else {
13290                 if esep {
13291                         for k2, v2 := range v {
13292                                 ee.WriteMapElemKey()
13293                                 ee.EncodeInt(int64(k2))
13294                                 ee.WriteMapElemValue()
13295                                 ee.EncodeFloat64(v2)
13296                         }
13297                 } else {
13298                         for k2, v2 := range v {
13299                                 ee.EncodeInt(int64(k2))
13300                                 ee.EncodeFloat64(v2)
13301                         }
13302                 }
13303         }
13304         ee.WriteMapEnd()
13305 }
13306
13307 func (e *Encoder) fastpathEncMapInt32BoolR(f *codecFnInfo, rv reflect.Value) {
13308         fastpathTV.EncMapInt32BoolV(rv2i(rv).(map[int32]bool), e)
13309 }
13310 func (_ fastpathT) EncMapInt32BoolV(v map[int32]bool, e *Encoder) {
13311         if v == nil {
13312                 e.e.EncodeNil()
13313                 return
13314         }
13315         ee, esep := e.e, e.hh.hasElemSeparators()
13316         ee.WriteMapStart(len(v))
13317         if e.h.Canonical {
13318                 v2 := make([]int64, len(v))
13319                 var i int
13320                 for k, _ := range v {
13321                         v2[i] = int64(k)
13322                         i++
13323                 }
13324                 sort.Sort(intSlice(v2))
13325                 if esep {
13326                         for _, k2 := range v2 {
13327                                 ee.WriteMapElemKey()
13328                                 ee.EncodeInt(int64(int32(k2)))
13329                                 ee.WriteMapElemValue()
13330                                 ee.EncodeBool(v[int32(k2)])
13331                         }
13332                 } else {
13333                         for _, k2 := range v2 {
13334                                 ee.EncodeInt(int64(int32(k2)))
13335                                 ee.EncodeBool(v[int32(k2)])
13336                         }
13337                 }
13338         } else {
13339                 if esep {
13340                         for k2, v2 := range v {
13341                                 ee.WriteMapElemKey()
13342                                 ee.EncodeInt(int64(k2))
13343                                 ee.WriteMapElemValue()
13344                                 ee.EncodeBool(v2)
13345                         }
13346                 } else {
13347                         for k2, v2 := range v {
13348                                 ee.EncodeInt(int64(k2))
13349                                 ee.EncodeBool(v2)
13350                         }
13351                 }
13352         }
13353         ee.WriteMapEnd()
13354 }
13355
13356 func (e *Encoder) fastpathEncMapInt64IntfR(f *codecFnInfo, rv reflect.Value) {
13357         fastpathTV.EncMapInt64IntfV(rv2i(rv).(map[int64]interface{}), e)
13358 }
13359 func (_ fastpathT) EncMapInt64IntfV(v map[int64]interface{}, e *Encoder) {
13360         if v == nil {
13361                 e.e.EncodeNil()
13362                 return
13363         }
13364         ee, esep := e.e, e.hh.hasElemSeparators()
13365         ee.WriteMapStart(len(v))
13366         if e.h.Canonical {
13367                 v2 := make([]int64, len(v))
13368                 var i int
13369                 for k, _ := range v {
13370                         v2[i] = int64(k)
13371                         i++
13372                 }
13373                 sort.Sort(intSlice(v2))
13374                 if esep {
13375                         for _, k2 := range v2 {
13376                                 ee.WriteMapElemKey()
13377                                 ee.EncodeInt(int64(int64(k2)))
13378                                 ee.WriteMapElemValue()
13379                                 e.encode(v[int64(k2)])
13380                         }
13381                 } else {
13382                         for _, k2 := range v2 {
13383                                 ee.EncodeInt(int64(int64(k2)))
13384                                 e.encode(v[int64(k2)])
13385                         }
13386                 }
13387         } else {
13388                 if esep {
13389                         for k2, v2 := range v {
13390                                 ee.WriteMapElemKey()
13391                                 ee.EncodeInt(int64(k2))
13392                                 ee.WriteMapElemValue()
13393                                 e.encode(v2)
13394                         }
13395                 } else {
13396                         for k2, v2 := range v {
13397                                 ee.EncodeInt(int64(k2))
13398                                 e.encode(v2)
13399                         }
13400                 }
13401         }
13402         ee.WriteMapEnd()
13403 }
13404
13405 func (e *Encoder) fastpathEncMapInt64StringR(f *codecFnInfo, rv reflect.Value) {
13406         fastpathTV.EncMapInt64StringV(rv2i(rv).(map[int64]string), e)
13407 }
13408 func (_ fastpathT) EncMapInt64StringV(v map[int64]string, e *Encoder) {
13409         if v == nil {
13410                 e.e.EncodeNil()
13411                 return
13412         }
13413         ee, esep := e.e, e.hh.hasElemSeparators()
13414         ee.WriteMapStart(len(v))
13415         if e.h.Canonical {
13416                 v2 := make([]int64, len(v))
13417                 var i int
13418                 for k, _ := range v {
13419                         v2[i] = int64(k)
13420                         i++
13421                 }
13422                 sort.Sort(intSlice(v2))
13423                 if esep {
13424                         for _, k2 := range v2 {
13425                                 ee.WriteMapElemKey()
13426                                 ee.EncodeInt(int64(int64(k2)))
13427                                 ee.WriteMapElemValue()
13428                                 ee.EncodeString(cUTF8, v[int64(k2)])
13429                         }
13430                 } else {
13431                         for _, k2 := range v2 {
13432                                 ee.EncodeInt(int64(int64(k2)))
13433                                 ee.EncodeString(cUTF8, v[int64(k2)])
13434                         }
13435                 }
13436         } else {
13437                 if esep {
13438                         for k2, v2 := range v {
13439                                 ee.WriteMapElemKey()
13440                                 ee.EncodeInt(int64(k2))
13441                                 ee.WriteMapElemValue()
13442                                 ee.EncodeString(cUTF8, v2)
13443                         }
13444                 } else {
13445                         for k2, v2 := range v {
13446                                 ee.EncodeInt(int64(k2))
13447                                 ee.EncodeString(cUTF8, v2)
13448                         }
13449                 }
13450         }
13451         ee.WriteMapEnd()
13452 }
13453
13454 func (e *Encoder) fastpathEncMapInt64UintR(f *codecFnInfo, rv reflect.Value) {
13455         fastpathTV.EncMapInt64UintV(rv2i(rv).(map[int64]uint), e)
13456 }
13457 func (_ fastpathT) EncMapInt64UintV(v map[int64]uint, e *Encoder) {
13458         if v == nil {
13459                 e.e.EncodeNil()
13460                 return
13461         }
13462         ee, esep := e.e, e.hh.hasElemSeparators()
13463         ee.WriteMapStart(len(v))
13464         if e.h.Canonical {
13465                 v2 := make([]int64, len(v))
13466                 var i int
13467                 for k, _ := range v {
13468                         v2[i] = int64(k)
13469                         i++
13470                 }
13471                 sort.Sort(intSlice(v2))
13472                 if esep {
13473                         for _, k2 := range v2 {
13474                                 ee.WriteMapElemKey()
13475                                 ee.EncodeInt(int64(int64(k2)))
13476                                 ee.WriteMapElemValue()
13477                                 ee.EncodeUint(uint64(v[int64(k2)]))
13478                         }
13479                 } else {
13480                         for _, k2 := range v2 {
13481                                 ee.EncodeInt(int64(int64(k2)))
13482                                 ee.EncodeUint(uint64(v[int64(k2)]))
13483                         }
13484                 }
13485         } else {
13486                 if esep {
13487                         for k2, v2 := range v {
13488                                 ee.WriteMapElemKey()
13489                                 ee.EncodeInt(int64(k2))
13490                                 ee.WriteMapElemValue()
13491                                 ee.EncodeUint(uint64(v2))
13492                         }
13493                 } else {
13494                         for k2, v2 := range v {
13495                                 ee.EncodeInt(int64(k2))
13496                                 ee.EncodeUint(uint64(v2))
13497                         }
13498                 }
13499         }
13500         ee.WriteMapEnd()
13501 }
13502
13503 func (e *Encoder) fastpathEncMapInt64Uint8R(f *codecFnInfo, rv reflect.Value) {
13504         fastpathTV.EncMapInt64Uint8V(rv2i(rv).(map[int64]uint8), e)
13505 }
13506 func (_ fastpathT) EncMapInt64Uint8V(v map[int64]uint8, e *Encoder) {
13507         if v == nil {
13508                 e.e.EncodeNil()
13509                 return
13510         }
13511         ee, esep := e.e, e.hh.hasElemSeparators()
13512         ee.WriteMapStart(len(v))
13513         if e.h.Canonical {
13514                 v2 := make([]int64, len(v))
13515                 var i int
13516                 for k, _ := range v {
13517                         v2[i] = int64(k)
13518                         i++
13519                 }
13520                 sort.Sort(intSlice(v2))
13521                 if esep {
13522                         for _, k2 := range v2 {
13523                                 ee.WriteMapElemKey()
13524                                 ee.EncodeInt(int64(int64(k2)))
13525                                 ee.WriteMapElemValue()
13526                                 ee.EncodeUint(uint64(v[int64(k2)]))
13527                         }
13528                 } else {
13529                         for _, k2 := range v2 {
13530                                 ee.EncodeInt(int64(int64(k2)))
13531                                 ee.EncodeUint(uint64(v[int64(k2)]))
13532                         }
13533                 }
13534         } else {
13535                 if esep {
13536                         for k2, v2 := range v {
13537                                 ee.WriteMapElemKey()
13538                                 ee.EncodeInt(int64(k2))
13539                                 ee.WriteMapElemValue()
13540                                 ee.EncodeUint(uint64(v2))
13541                         }
13542                 } else {
13543                         for k2, v2 := range v {
13544                                 ee.EncodeInt(int64(k2))
13545                                 ee.EncodeUint(uint64(v2))
13546                         }
13547                 }
13548         }
13549         ee.WriteMapEnd()
13550 }
13551
13552 func (e *Encoder) fastpathEncMapInt64Uint16R(f *codecFnInfo, rv reflect.Value) {
13553         fastpathTV.EncMapInt64Uint16V(rv2i(rv).(map[int64]uint16), e)
13554 }
13555 func (_ fastpathT) EncMapInt64Uint16V(v map[int64]uint16, e *Encoder) {
13556         if v == nil {
13557                 e.e.EncodeNil()
13558                 return
13559         }
13560         ee, esep := e.e, e.hh.hasElemSeparators()
13561         ee.WriteMapStart(len(v))
13562         if e.h.Canonical {
13563                 v2 := make([]int64, len(v))
13564                 var i int
13565                 for k, _ := range v {
13566                         v2[i] = int64(k)
13567                         i++
13568                 }
13569                 sort.Sort(intSlice(v2))
13570                 if esep {
13571                         for _, k2 := range v2 {
13572                                 ee.WriteMapElemKey()
13573                                 ee.EncodeInt(int64(int64(k2)))
13574                                 ee.WriteMapElemValue()
13575                                 ee.EncodeUint(uint64(v[int64(k2)]))
13576                         }
13577                 } else {
13578                         for _, k2 := range v2 {
13579                                 ee.EncodeInt(int64(int64(k2)))
13580                                 ee.EncodeUint(uint64(v[int64(k2)]))
13581                         }
13582                 }
13583         } else {
13584                 if esep {
13585                         for k2, v2 := range v {
13586                                 ee.WriteMapElemKey()
13587                                 ee.EncodeInt(int64(k2))
13588                                 ee.WriteMapElemValue()
13589                                 ee.EncodeUint(uint64(v2))
13590                         }
13591                 } else {
13592                         for k2, v2 := range v {
13593                                 ee.EncodeInt(int64(k2))
13594                                 ee.EncodeUint(uint64(v2))
13595                         }
13596                 }
13597         }
13598         ee.WriteMapEnd()
13599 }
13600
13601 func (e *Encoder) fastpathEncMapInt64Uint32R(f *codecFnInfo, rv reflect.Value) {
13602         fastpathTV.EncMapInt64Uint32V(rv2i(rv).(map[int64]uint32), e)
13603 }
13604 func (_ fastpathT) EncMapInt64Uint32V(v map[int64]uint32, e *Encoder) {
13605         if v == nil {
13606                 e.e.EncodeNil()
13607                 return
13608         }
13609         ee, esep := e.e, e.hh.hasElemSeparators()
13610         ee.WriteMapStart(len(v))
13611         if e.h.Canonical {
13612                 v2 := make([]int64, len(v))
13613                 var i int
13614                 for k, _ := range v {
13615                         v2[i] = int64(k)
13616                         i++
13617                 }
13618                 sort.Sort(intSlice(v2))
13619                 if esep {
13620                         for _, k2 := range v2 {
13621                                 ee.WriteMapElemKey()
13622                                 ee.EncodeInt(int64(int64(k2)))
13623                                 ee.WriteMapElemValue()
13624                                 ee.EncodeUint(uint64(v[int64(k2)]))
13625                         }
13626                 } else {
13627                         for _, k2 := range v2 {
13628                                 ee.EncodeInt(int64(int64(k2)))
13629                                 ee.EncodeUint(uint64(v[int64(k2)]))
13630                         }
13631                 }
13632         } else {
13633                 if esep {
13634                         for k2, v2 := range v {
13635                                 ee.WriteMapElemKey()
13636                                 ee.EncodeInt(int64(k2))
13637                                 ee.WriteMapElemValue()
13638                                 ee.EncodeUint(uint64(v2))
13639                         }
13640                 } else {
13641                         for k2, v2 := range v {
13642                                 ee.EncodeInt(int64(k2))
13643                                 ee.EncodeUint(uint64(v2))
13644                         }
13645                 }
13646         }
13647         ee.WriteMapEnd()
13648 }
13649
13650 func (e *Encoder) fastpathEncMapInt64Uint64R(f *codecFnInfo, rv reflect.Value) {
13651         fastpathTV.EncMapInt64Uint64V(rv2i(rv).(map[int64]uint64), e)
13652 }
13653 func (_ fastpathT) EncMapInt64Uint64V(v map[int64]uint64, e *Encoder) {
13654         if v == nil {
13655                 e.e.EncodeNil()
13656                 return
13657         }
13658         ee, esep := e.e, e.hh.hasElemSeparators()
13659         ee.WriteMapStart(len(v))
13660         if e.h.Canonical {
13661                 v2 := make([]int64, len(v))
13662                 var i int
13663                 for k, _ := range v {
13664                         v2[i] = int64(k)
13665                         i++
13666                 }
13667                 sort.Sort(intSlice(v2))
13668                 if esep {
13669                         for _, k2 := range v2 {
13670                                 ee.WriteMapElemKey()
13671                                 ee.EncodeInt(int64(int64(k2)))
13672                                 ee.WriteMapElemValue()
13673                                 ee.EncodeUint(uint64(v[int64(k2)]))
13674                         }
13675                 } else {
13676                         for _, k2 := range v2 {
13677                                 ee.EncodeInt(int64(int64(k2)))
13678                                 ee.EncodeUint(uint64(v[int64(k2)]))
13679                         }
13680                 }
13681         } else {
13682                 if esep {
13683                         for k2, v2 := range v {
13684                                 ee.WriteMapElemKey()
13685                                 ee.EncodeInt(int64(k2))
13686                                 ee.WriteMapElemValue()
13687                                 ee.EncodeUint(uint64(v2))
13688                         }
13689                 } else {
13690                         for k2, v2 := range v {
13691                                 ee.EncodeInt(int64(k2))
13692                                 ee.EncodeUint(uint64(v2))
13693                         }
13694                 }
13695         }
13696         ee.WriteMapEnd()
13697 }
13698
13699 func (e *Encoder) fastpathEncMapInt64UintptrR(f *codecFnInfo, rv reflect.Value) {
13700         fastpathTV.EncMapInt64UintptrV(rv2i(rv).(map[int64]uintptr), e)
13701 }
13702 func (_ fastpathT) EncMapInt64UintptrV(v map[int64]uintptr, e *Encoder) {
13703         if v == nil {
13704                 e.e.EncodeNil()
13705                 return
13706         }
13707         ee, esep := e.e, e.hh.hasElemSeparators()
13708         ee.WriteMapStart(len(v))
13709         if e.h.Canonical {
13710                 v2 := make([]int64, len(v))
13711                 var i int
13712                 for k, _ := range v {
13713                         v2[i] = int64(k)
13714                         i++
13715                 }
13716                 sort.Sort(intSlice(v2))
13717                 if esep {
13718                         for _, k2 := range v2 {
13719                                 ee.WriteMapElemKey()
13720                                 ee.EncodeInt(int64(int64(k2)))
13721                                 ee.WriteMapElemValue()
13722                                 e.encode(v[int64(k2)])
13723                         }
13724                 } else {
13725                         for _, k2 := range v2 {
13726                                 ee.EncodeInt(int64(int64(k2)))
13727                                 e.encode(v[int64(k2)])
13728                         }
13729                 }
13730         } else {
13731                 if esep {
13732                         for k2, v2 := range v {
13733                                 ee.WriteMapElemKey()
13734                                 ee.EncodeInt(int64(k2))
13735                                 ee.WriteMapElemValue()
13736                                 e.encode(v2)
13737                         }
13738                 } else {
13739                         for k2, v2 := range v {
13740                                 ee.EncodeInt(int64(k2))
13741                                 e.encode(v2)
13742                         }
13743                 }
13744         }
13745         ee.WriteMapEnd()
13746 }
13747
13748 func (e *Encoder) fastpathEncMapInt64IntR(f *codecFnInfo, rv reflect.Value) {
13749         fastpathTV.EncMapInt64IntV(rv2i(rv).(map[int64]int), e)
13750 }
13751 func (_ fastpathT) EncMapInt64IntV(v map[int64]int, e *Encoder) {
13752         if v == nil {
13753                 e.e.EncodeNil()
13754                 return
13755         }
13756         ee, esep := e.e, e.hh.hasElemSeparators()
13757         ee.WriteMapStart(len(v))
13758         if e.h.Canonical {
13759                 v2 := make([]int64, len(v))
13760                 var i int
13761                 for k, _ := range v {
13762                         v2[i] = int64(k)
13763                         i++
13764                 }
13765                 sort.Sort(intSlice(v2))
13766                 if esep {
13767                         for _, k2 := range v2 {
13768                                 ee.WriteMapElemKey()
13769                                 ee.EncodeInt(int64(int64(k2)))
13770                                 ee.WriteMapElemValue()
13771                                 ee.EncodeInt(int64(v[int64(k2)]))
13772                         }
13773                 } else {
13774                         for _, k2 := range v2 {
13775                                 ee.EncodeInt(int64(int64(k2)))
13776                                 ee.EncodeInt(int64(v[int64(k2)]))
13777                         }
13778                 }
13779         } else {
13780                 if esep {
13781                         for k2, v2 := range v {
13782                                 ee.WriteMapElemKey()
13783                                 ee.EncodeInt(int64(k2))
13784                                 ee.WriteMapElemValue()
13785                                 ee.EncodeInt(int64(v2))
13786                         }
13787                 } else {
13788                         for k2, v2 := range v {
13789                                 ee.EncodeInt(int64(k2))
13790                                 ee.EncodeInt(int64(v2))
13791                         }
13792                 }
13793         }
13794         ee.WriteMapEnd()
13795 }
13796
13797 func (e *Encoder) fastpathEncMapInt64Int8R(f *codecFnInfo, rv reflect.Value) {
13798         fastpathTV.EncMapInt64Int8V(rv2i(rv).(map[int64]int8), e)
13799 }
13800 func (_ fastpathT) EncMapInt64Int8V(v map[int64]int8, e *Encoder) {
13801         if v == nil {
13802                 e.e.EncodeNil()
13803                 return
13804         }
13805         ee, esep := e.e, e.hh.hasElemSeparators()
13806         ee.WriteMapStart(len(v))
13807         if e.h.Canonical {
13808                 v2 := make([]int64, len(v))
13809                 var i int
13810                 for k, _ := range v {
13811                         v2[i] = int64(k)
13812                         i++
13813                 }
13814                 sort.Sort(intSlice(v2))
13815                 if esep {
13816                         for _, k2 := range v2 {
13817                                 ee.WriteMapElemKey()
13818                                 ee.EncodeInt(int64(int64(k2)))
13819                                 ee.WriteMapElemValue()
13820                                 ee.EncodeInt(int64(v[int64(k2)]))
13821                         }
13822                 } else {
13823                         for _, k2 := range v2 {
13824                                 ee.EncodeInt(int64(int64(k2)))
13825                                 ee.EncodeInt(int64(v[int64(k2)]))
13826                         }
13827                 }
13828         } else {
13829                 if esep {
13830                         for k2, v2 := range v {
13831                                 ee.WriteMapElemKey()
13832                                 ee.EncodeInt(int64(k2))
13833                                 ee.WriteMapElemValue()
13834                                 ee.EncodeInt(int64(v2))
13835                         }
13836                 } else {
13837                         for k2, v2 := range v {
13838                                 ee.EncodeInt(int64(k2))
13839                                 ee.EncodeInt(int64(v2))
13840                         }
13841                 }
13842         }
13843         ee.WriteMapEnd()
13844 }
13845
13846 func (e *Encoder) fastpathEncMapInt64Int16R(f *codecFnInfo, rv reflect.Value) {
13847         fastpathTV.EncMapInt64Int16V(rv2i(rv).(map[int64]int16), e)
13848 }
13849 func (_ fastpathT) EncMapInt64Int16V(v map[int64]int16, e *Encoder) {
13850         if v == nil {
13851                 e.e.EncodeNil()
13852                 return
13853         }
13854         ee, esep := e.e, e.hh.hasElemSeparators()
13855         ee.WriteMapStart(len(v))
13856         if e.h.Canonical {
13857                 v2 := make([]int64, len(v))
13858                 var i int
13859                 for k, _ := range v {
13860                         v2[i] = int64(k)
13861                         i++
13862                 }
13863                 sort.Sort(intSlice(v2))
13864                 if esep {
13865                         for _, k2 := range v2 {
13866                                 ee.WriteMapElemKey()
13867                                 ee.EncodeInt(int64(int64(k2)))
13868                                 ee.WriteMapElemValue()
13869                                 ee.EncodeInt(int64(v[int64(k2)]))
13870                         }
13871                 } else {
13872                         for _, k2 := range v2 {
13873                                 ee.EncodeInt(int64(int64(k2)))
13874                                 ee.EncodeInt(int64(v[int64(k2)]))
13875                         }
13876                 }
13877         } else {
13878                 if esep {
13879                         for k2, v2 := range v {
13880                                 ee.WriteMapElemKey()
13881                                 ee.EncodeInt(int64(k2))
13882                                 ee.WriteMapElemValue()
13883                                 ee.EncodeInt(int64(v2))
13884                         }
13885                 } else {
13886                         for k2, v2 := range v {
13887                                 ee.EncodeInt(int64(k2))
13888                                 ee.EncodeInt(int64(v2))
13889                         }
13890                 }
13891         }
13892         ee.WriteMapEnd()
13893 }
13894
13895 func (e *Encoder) fastpathEncMapInt64Int32R(f *codecFnInfo, rv reflect.Value) {
13896         fastpathTV.EncMapInt64Int32V(rv2i(rv).(map[int64]int32), e)
13897 }
13898 func (_ fastpathT) EncMapInt64Int32V(v map[int64]int32, e *Encoder) {
13899         if v == nil {
13900                 e.e.EncodeNil()
13901                 return
13902         }
13903         ee, esep := e.e, e.hh.hasElemSeparators()
13904         ee.WriteMapStart(len(v))
13905         if e.h.Canonical {
13906                 v2 := make([]int64, len(v))
13907                 var i int
13908                 for k, _ := range v {
13909                         v2[i] = int64(k)
13910                         i++
13911                 }
13912                 sort.Sort(intSlice(v2))
13913                 if esep {
13914                         for _, k2 := range v2 {
13915                                 ee.WriteMapElemKey()
13916                                 ee.EncodeInt(int64(int64(k2)))
13917                                 ee.WriteMapElemValue()
13918                                 ee.EncodeInt(int64(v[int64(k2)]))
13919                         }
13920                 } else {
13921                         for _, k2 := range v2 {
13922                                 ee.EncodeInt(int64(int64(k2)))
13923                                 ee.EncodeInt(int64(v[int64(k2)]))
13924                         }
13925                 }
13926         } else {
13927                 if esep {
13928                         for k2, v2 := range v {
13929                                 ee.WriteMapElemKey()
13930                                 ee.EncodeInt(int64(k2))
13931                                 ee.WriteMapElemValue()
13932                                 ee.EncodeInt(int64(v2))
13933                         }
13934                 } else {
13935                         for k2, v2 := range v {
13936                                 ee.EncodeInt(int64(k2))
13937                                 ee.EncodeInt(int64(v2))
13938                         }
13939                 }
13940         }
13941         ee.WriteMapEnd()
13942 }
13943
13944 func (e *Encoder) fastpathEncMapInt64Int64R(f *codecFnInfo, rv reflect.Value) {
13945         fastpathTV.EncMapInt64Int64V(rv2i(rv).(map[int64]int64), e)
13946 }
13947 func (_ fastpathT) EncMapInt64Int64V(v map[int64]int64, e *Encoder) {
13948         if v == nil {
13949                 e.e.EncodeNil()
13950                 return
13951         }
13952         ee, esep := e.e, e.hh.hasElemSeparators()
13953         ee.WriteMapStart(len(v))
13954         if e.h.Canonical {
13955                 v2 := make([]int64, len(v))
13956                 var i int
13957                 for k, _ := range v {
13958                         v2[i] = int64(k)
13959                         i++
13960                 }
13961                 sort.Sort(intSlice(v2))
13962                 if esep {
13963                         for _, k2 := range v2 {
13964                                 ee.WriteMapElemKey()
13965                                 ee.EncodeInt(int64(int64(k2)))
13966                                 ee.WriteMapElemValue()
13967                                 ee.EncodeInt(int64(v[int64(k2)]))
13968                         }
13969                 } else {
13970                         for _, k2 := range v2 {
13971                                 ee.EncodeInt(int64(int64(k2)))
13972                                 ee.EncodeInt(int64(v[int64(k2)]))
13973                         }
13974                 }
13975         } else {
13976                 if esep {
13977                         for k2, v2 := range v {
13978                                 ee.WriteMapElemKey()
13979                                 ee.EncodeInt(int64(k2))
13980                                 ee.WriteMapElemValue()
13981                                 ee.EncodeInt(int64(v2))
13982                         }
13983                 } else {
13984                         for k2, v2 := range v {
13985                                 ee.EncodeInt(int64(k2))
13986                                 ee.EncodeInt(int64(v2))
13987                         }
13988                 }
13989         }
13990         ee.WriteMapEnd()
13991 }
13992
13993 func (e *Encoder) fastpathEncMapInt64Float32R(f *codecFnInfo, rv reflect.Value) {
13994         fastpathTV.EncMapInt64Float32V(rv2i(rv).(map[int64]float32), e)
13995 }
13996 func (_ fastpathT) EncMapInt64Float32V(v map[int64]float32, e *Encoder) {
13997         if v == nil {
13998                 e.e.EncodeNil()
13999                 return
14000         }
14001         ee, esep := e.e, e.hh.hasElemSeparators()
14002         ee.WriteMapStart(len(v))
14003         if e.h.Canonical {
14004                 v2 := make([]int64, len(v))
14005                 var i int
14006                 for k, _ := range v {
14007                         v2[i] = int64(k)
14008                         i++
14009                 }
14010                 sort.Sort(intSlice(v2))
14011                 if esep {
14012                         for _, k2 := range v2 {
14013                                 ee.WriteMapElemKey()
14014                                 ee.EncodeInt(int64(int64(k2)))
14015                                 ee.WriteMapElemValue()
14016                                 ee.EncodeFloat32(v[int64(k2)])
14017                         }
14018                 } else {
14019                         for _, k2 := range v2 {
14020                                 ee.EncodeInt(int64(int64(k2)))
14021                                 ee.EncodeFloat32(v[int64(k2)])
14022                         }
14023                 }
14024         } else {
14025                 if esep {
14026                         for k2, v2 := range v {
14027                                 ee.WriteMapElemKey()
14028                                 ee.EncodeInt(int64(k2))
14029                                 ee.WriteMapElemValue()
14030                                 ee.EncodeFloat32(v2)
14031                         }
14032                 } else {
14033                         for k2, v2 := range v {
14034                                 ee.EncodeInt(int64(k2))
14035                                 ee.EncodeFloat32(v2)
14036                         }
14037                 }
14038         }
14039         ee.WriteMapEnd()
14040 }
14041
14042 func (e *Encoder) fastpathEncMapInt64Float64R(f *codecFnInfo, rv reflect.Value) {
14043         fastpathTV.EncMapInt64Float64V(rv2i(rv).(map[int64]float64), e)
14044 }
14045 func (_ fastpathT) EncMapInt64Float64V(v map[int64]float64, e *Encoder) {
14046         if v == nil {
14047                 e.e.EncodeNil()
14048                 return
14049         }
14050         ee, esep := e.e, e.hh.hasElemSeparators()
14051         ee.WriteMapStart(len(v))
14052         if e.h.Canonical {
14053                 v2 := make([]int64, len(v))
14054                 var i int
14055                 for k, _ := range v {
14056                         v2[i] = int64(k)
14057                         i++
14058                 }
14059                 sort.Sort(intSlice(v2))
14060                 if esep {
14061                         for _, k2 := range v2 {
14062                                 ee.WriteMapElemKey()
14063                                 ee.EncodeInt(int64(int64(k2)))
14064                                 ee.WriteMapElemValue()
14065                                 ee.EncodeFloat64(v[int64(k2)])
14066                         }
14067                 } else {
14068                         for _, k2 := range v2 {
14069                                 ee.EncodeInt(int64(int64(k2)))
14070                                 ee.EncodeFloat64(v[int64(k2)])
14071                         }
14072                 }
14073         } else {
14074                 if esep {
14075                         for k2, v2 := range v {
14076                                 ee.WriteMapElemKey()
14077                                 ee.EncodeInt(int64(k2))
14078                                 ee.WriteMapElemValue()
14079                                 ee.EncodeFloat64(v2)
14080                         }
14081                 } else {
14082                         for k2, v2 := range v {
14083                                 ee.EncodeInt(int64(k2))
14084                                 ee.EncodeFloat64(v2)
14085                         }
14086                 }
14087         }
14088         ee.WriteMapEnd()
14089 }
14090
14091 func (e *Encoder) fastpathEncMapInt64BoolR(f *codecFnInfo, rv reflect.Value) {
14092         fastpathTV.EncMapInt64BoolV(rv2i(rv).(map[int64]bool), e)
14093 }
14094 func (_ fastpathT) EncMapInt64BoolV(v map[int64]bool, e *Encoder) {
14095         if v == nil {
14096                 e.e.EncodeNil()
14097                 return
14098         }
14099         ee, esep := e.e, e.hh.hasElemSeparators()
14100         ee.WriteMapStart(len(v))
14101         if e.h.Canonical {
14102                 v2 := make([]int64, len(v))
14103                 var i int
14104                 for k, _ := range v {
14105                         v2[i] = int64(k)
14106                         i++
14107                 }
14108                 sort.Sort(intSlice(v2))
14109                 if esep {
14110                         for _, k2 := range v2 {
14111                                 ee.WriteMapElemKey()
14112                                 ee.EncodeInt(int64(int64(k2)))
14113                                 ee.WriteMapElemValue()
14114                                 ee.EncodeBool(v[int64(k2)])
14115                         }
14116                 } else {
14117                         for _, k2 := range v2 {
14118                                 ee.EncodeInt(int64(int64(k2)))
14119                                 ee.EncodeBool(v[int64(k2)])
14120                         }
14121                 }
14122         } else {
14123                 if esep {
14124                         for k2, v2 := range v {
14125                                 ee.WriteMapElemKey()
14126                                 ee.EncodeInt(int64(k2))
14127                                 ee.WriteMapElemValue()
14128                                 ee.EncodeBool(v2)
14129                         }
14130                 } else {
14131                         for k2, v2 := range v {
14132                                 ee.EncodeInt(int64(k2))
14133                                 ee.EncodeBool(v2)
14134                         }
14135                 }
14136         }
14137         ee.WriteMapEnd()
14138 }
14139
14140 func (e *Encoder) fastpathEncMapBoolIntfR(f *codecFnInfo, rv reflect.Value) {
14141         fastpathTV.EncMapBoolIntfV(rv2i(rv).(map[bool]interface{}), e)
14142 }
14143 func (_ fastpathT) EncMapBoolIntfV(v map[bool]interface{}, e *Encoder) {
14144         if v == nil {
14145                 e.e.EncodeNil()
14146                 return
14147         }
14148         ee, esep := e.e, e.hh.hasElemSeparators()
14149         ee.WriteMapStart(len(v))
14150         if e.h.Canonical {
14151                 v2 := make([]bool, len(v))
14152                 var i int
14153                 for k, _ := range v {
14154                         v2[i] = bool(k)
14155                         i++
14156                 }
14157                 sort.Sort(boolSlice(v2))
14158                 if esep {
14159                         for _, k2 := range v2 {
14160                                 ee.WriteMapElemKey()
14161                                 ee.EncodeBool(bool(k2))
14162                                 ee.WriteMapElemValue()
14163                                 e.encode(v[bool(k2)])
14164                         }
14165                 } else {
14166                         for _, k2 := range v2 {
14167                                 ee.EncodeBool(bool(k2))
14168                                 e.encode(v[bool(k2)])
14169                         }
14170                 }
14171         } else {
14172                 if esep {
14173                         for k2, v2 := range v {
14174                                 ee.WriteMapElemKey()
14175                                 ee.EncodeBool(k2)
14176                                 ee.WriteMapElemValue()
14177                                 e.encode(v2)
14178                         }
14179                 } else {
14180                         for k2, v2 := range v {
14181                                 ee.EncodeBool(k2)
14182                                 e.encode(v2)
14183                         }
14184                 }
14185         }
14186         ee.WriteMapEnd()
14187 }
14188
14189 func (e *Encoder) fastpathEncMapBoolStringR(f *codecFnInfo, rv reflect.Value) {
14190         fastpathTV.EncMapBoolStringV(rv2i(rv).(map[bool]string), e)
14191 }
14192 func (_ fastpathT) EncMapBoolStringV(v map[bool]string, e *Encoder) {
14193         if v == nil {
14194                 e.e.EncodeNil()
14195                 return
14196         }
14197         ee, esep := e.e, e.hh.hasElemSeparators()
14198         ee.WriteMapStart(len(v))
14199         if e.h.Canonical {
14200                 v2 := make([]bool, len(v))
14201                 var i int
14202                 for k, _ := range v {
14203                         v2[i] = bool(k)
14204                         i++
14205                 }
14206                 sort.Sort(boolSlice(v2))
14207                 if esep {
14208                         for _, k2 := range v2 {
14209                                 ee.WriteMapElemKey()
14210                                 ee.EncodeBool(bool(k2))
14211                                 ee.WriteMapElemValue()
14212                                 ee.EncodeString(cUTF8, v[bool(k2)])
14213                         }
14214                 } else {
14215                         for _, k2 := range v2 {
14216                                 ee.EncodeBool(bool(k2))
14217                                 ee.EncodeString(cUTF8, v[bool(k2)])
14218                         }
14219                 }
14220         } else {
14221                 if esep {
14222                         for k2, v2 := range v {
14223                                 ee.WriteMapElemKey()
14224                                 ee.EncodeBool(k2)
14225                                 ee.WriteMapElemValue()
14226                                 ee.EncodeString(cUTF8, v2)
14227                         }
14228                 } else {
14229                         for k2, v2 := range v {
14230                                 ee.EncodeBool(k2)
14231                                 ee.EncodeString(cUTF8, v2)
14232                         }
14233                 }
14234         }
14235         ee.WriteMapEnd()
14236 }
14237
14238 func (e *Encoder) fastpathEncMapBoolUintR(f *codecFnInfo, rv reflect.Value) {
14239         fastpathTV.EncMapBoolUintV(rv2i(rv).(map[bool]uint), e)
14240 }
14241 func (_ fastpathT) EncMapBoolUintV(v map[bool]uint, e *Encoder) {
14242         if v == nil {
14243                 e.e.EncodeNil()
14244                 return
14245         }
14246         ee, esep := e.e, e.hh.hasElemSeparators()
14247         ee.WriteMapStart(len(v))
14248         if e.h.Canonical {
14249                 v2 := make([]bool, len(v))
14250                 var i int
14251                 for k, _ := range v {
14252                         v2[i] = bool(k)
14253                         i++
14254                 }
14255                 sort.Sort(boolSlice(v2))
14256                 if esep {
14257                         for _, k2 := range v2 {
14258                                 ee.WriteMapElemKey()
14259                                 ee.EncodeBool(bool(k2))
14260                                 ee.WriteMapElemValue()
14261                                 ee.EncodeUint(uint64(v[bool(k2)]))
14262                         }
14263                 } else {
14264                         for _, k2 := range v2 {
14265                                 ee.EncodeBool(bool(k2))
14266                                 ee.EncodeUint(uint64(v[bool(k2)]))
14267                         }
14268                 }
14269         } else {
14270                 if esep {
14271                         for k2, v2 := range v {
14272                                 ee.WriteMapElemKey()
14273                                 ee.EncodeBool(k2)
14274                                 ee.WriteMapElemValue()
14275                                 ee.EncodeUint(uint64(v2))
14276                         }
14277                 } else {
14278                         for k2, v2 := range v {
14279                                 ee.EncodeBool(k2)
14280                                 ee.EncodeUint(uint64(v2))
14281                         }
14282                 }
14283         }
14284         ee.WriteMapEnd()
14285 }
14286
14287 func (e *Encoder) fastpathEncMapBoolUint8R(f *codecFnInfo, rv reflect.Value) {
14288         fastpathTV.EncMapBoolUint8V(rv2i(rv).(map[bool]uint8), e)
14289 }
14290 func (_ fastpathT) EncMapBoolUint8V(v map[bool]uint8, e *Encoder) {
14291         if v == nil {
14292                 e.e.EncodeNil()
14293                 return
14294         }
14295         ee, esep := e.e, e.hh.hasElemSeparators()
14296         ee.WriteMapStart(len(v))
14297         if e.h.Canonical {
14298                 v2 := make([]bool, len(v))
14299                 var i int
14300                 for k, _ := range v {
14301                         v2[i] = bool(k)
14302                         i++
14303                 }
14304                 sort.Sort(boolSlice(v2))
14305                 if esep {
14306                         for _, k2 := range v2 {
14307                                 ee.WriteMapElemKey()
14308                                 ee.EncodeBool(bool(k2))
14309                                 ee.WriteMapElemValue()
14310                                 ee.EncodeUint(uint64(v[bool(k2)]))
14311                         }
14312                 } else {
14313                         for _, k2 := range v2 {
14314                                 ee.EncodeBool(bool(k2))
14315                                 ee.EncodeUint(uint64(v[bool(k2)]))
14316                         }
14317                 }
14318         } else {
14319                 if esep {
14320                         for k2, v2 := range v {
14321                                 ee.WriteMapElemKey()
14322                                 ee.EncodeBool(k2)
14323                                 ee.WriteMapElemValue()
14324                                 ee.EncodeUint(uint64(v2))
14325                         }
14326                 } else {
14327                         for k2, v2 := range v {
14328                                 ee.EncodeBool(k2)
14329                                 ee.EncodeUint(uint64(v2))
14330                         }
14331                 }
14332         }
14333         ee.WriteMapEnd()
14334 }
14335
14336 func (e *Encoder) fastpathEncMapBoolUint16R(f *codecFnInfo, rv reflect.Value) {
14337         fastpathTV.EncMapBoolUint16V(rv2i(rv).(map[bool]uint16), e)
14338 }
14339 func (_ fastpathT) EncMapBoolUint16V(v map[bool]uint16, e *Encoder) {
14340         if v == nil {
14341                 e.e.EncodeNil()
14342                 return
14343         }
14344         ee, esep := e.e, e.hh.hasElemSeparators()
14345         ee.WriteMapStart(len(v))
14346         if e.h.Canonical {
14347                 v2 := make([]bool, len(v))
14348                 var i int
14349                 for k, _ := range v {
14350                         v2[i] = bool(k)
14351                         i++
14352                 }
14353                 sort.Sort(boolSlice(v2))
14354                 if esep {
14355                         for _, k2 := range v2 {
14356                                 ee.WriteMapElemKey()
14357                                 ee.EncodeBool(bool(k2))
14358                                 ee.WriteMapElemValue()
14359                                 ee.EncodeUint(uint64(v[bool(k2)]))
14360                         }
14361                 } else {
14362                         for _, k2 := range v2 {
14363                                 ee.EncodeBool(bool(k2))
14364                                 ee.EncodeUint(uint64(v[bool(k2)]))
14365                         }
14366                 }
14367         } else {
14368                 if esep {
14369                         for k2, v2 := range v {
14370                                 ee.WriteMapElemKey()
14371                                 ee.EncodeBool(k2)
14372                                 ee.WriteMapElemValue()
14373                                 ee.EncodeUint(uint64(v2))
14374                         }
14375                 } else {
14376                         for k2, v2 := range v {
14377                                 ee.EncodeBool(k2)
14378                                 ee.EncodeUint(uint64(v2))
14379                         }
14380                 }
14381         }
14382         ee.WriteMapEnd()
14383 }
14384
14385 func (e *Encoder) fastpathEncMapBoolUint32R(f *codecFnInfo, rv reflect.Value) {
14386         fastpathTV.EncMapBoolUint32V(rv2i(rv).(map[bool]uint32), e)
14387 }
14388 func (_ fastpathT) EncMapBoolUint32V(v map[bool]uint32, e *Encoder) {
14389         if v == nil {
14390                 e.e.EncodeNil()
14391                 return
14392         }
14393         ee, esep := e.e, e.hh.hasElemSeparators()
14394         ee.WriteMapStart(len(v))
14395         if e.h.Canonical {
14396                 v2 := make([]bool, len(v))
14397                 var i int
14398                 for k, _ := range v {
14399                         v2[i] = bool(k)
14400                         i++
14401                 }
14402                 sort.Sort(boolSlice(v2))
14403                 if esep {
14404                         for _, k2 := range v2 {
14405                                 ee.WriteMapElemKey()
14406                                 ee.EncodeBool(bool(k2))
14407                                 ee.WriteMapElemValue()
14408                                 ee.EncodeUint(uint64(v[bool(k2)]))
14409                         }
14410                 } else {
14411                         for _, k2 := range v2 {
14412                                 ee.EncodeBool(bool(k2))
14413                                 ee.EncodeUint(uint64(v[bool(k2)]))
14414                         }
14415                 }
14416         } else {
14417                 if esep {
14418                         for k2, v2 := range v {
14419                                 ee.WriteMapElemKey()
14420                                 ee.EncodeBool(k2)
14421                                 ee.WriteMapElemValue()
14422                                 ee.EncodeUint(uint64(v2))
14423                         }
14424                 } else {
14425                         for k2, v2 := range v {
14426                                 ee.EncodeBool(k2)
14427                                 ee.EncodeUint(uint64(v2))
14428                         }
14429                 }
14430         }
14431         ee.WriteMapEnd()
14432 }
14433
14434 func (e *Encoder) fastpathEncMapBoolUint64R(f *codecFnInfo, rv reflect.Value) {
14435         fastpathTV.EncMapBoolUint64V(rv2i(rv).(map[bool]uint64), e)
14436 }
14437 func (_ fastpathT) EncMapBoolUint64V(v map[bool]uint64, e *Encoder) {
14438         if v == nil {
14439                 e.e.EncodeNil()
14440                 return
14441         }
14442         ee, esep := e.e, e.hh.hasElemSeparators()
14443         ee.WriteMapStart(len(v))
14444         if e.h.Canonical {
14445                 v2 := make([]bool, len(v))
14446                 var i int
14447                 for k, _ := range v {
14448                         v2[i] = bool(k)
14449                         i++
14450                 }
14451                 sort.Sort(boolSlice(v2))
14452                 if esep {
14453                         for _, k2 := range v2 {
14454                                 ee.WriteMapElemKey()
14455                                 ee.EncodeBool(bool(k2))
14456                                 ee.WriteMapElemValue()
14457                                 ee.EncodeUint(uint64(v[bool(k2)]))
14458                         }
14459                 } else {
14460                         for _, k2 := range v2 {
14461                                 ee.EncodeBool(bool(k2))
14462                                 ee.EncodeUint(uint64(v[bool(k2)]))
14463                         }
14464                 }
14465         } else {
14466                 if esep {
14467                         for k2, v2 := range v {
14468                                 ee.WriteMapElemKey()
14469                                 ee.EncodeBool(k2)
14470                                 ee.WriteMapElemValue()
14471                                 ee.EncodeUint(uint64(v2))
14472                         }
14473                 } else {
14474                         for k2, v2 := range v {
14475                                 ee.EncodeBool(k2)
14476                                 ee.EncodeUint(uint64(v2))
14477                         }
14478                 }
14479         }
14480         ee.WriteMapEnd()
14481 }
14482
14483 func (e *Encoder) fastpathEncMapBoolUintptrR(f *codecFnInfo, rv reflect.Value) {
14484         fastpathTV.EncMapBoolUintptrV(rv2i(rv).(map[bool]uintptr), e)
14485 }
14486 func (_ fastpathT) EncMapBoolUintptrV(v map[bool]uintptr, e *Encoder) {
14487         if v == nil {
14488                 e.e.EncodeNil()
14489                 return
14490         }
14491         ee, esep := e.e, e.hh.hasElemSeparators()
14492         ee.WriteMapStart(len(v))
14493         if e.h.Canonical {
14494                 v2 := make([]bool, len(v))
14495                 var i int
14496                 for k, _ := range v {
14497                         v2[i] = bool(k)
14498                         i++
14499                 }
14500                 sort.Sort(boolSlice(v2))
14501                 if esep {
14502                         for _, k2 := range v2 {
14503                                 ee.WriteMapElemKey()
14504                                 ee.EncodeBool(bool(k2))
14505                                 ee.WriteMapElemValue()
14506                                 e.encode(v[bool(k2)])
14507                         }
14508                 } else {
14509                         for _, k2 := range v2 {
14510                                 ee.EncodeBool(bool(k2))
14511                                 e.encode(v[bool(k2)])
14512                         }
14513                 }
14514         } else {
14515                 if esep {
14516                         for k2, v2 := range v {
14517                                 ee.WriteMapElemKey()
14518                                 ee.EncodeBool(k2)
14519                                 ee.WriteMapElemValue()
14520                                 e.encode(v2)
14521                         }
14522                 } else {
14523                         for k2, v2 := range v {
14524                                 ee.EncodeBool(k2)
14525                                 e.encode(v2)
14526                         }
14527                 }
14528         }
14529         ee.WriteMapEnd()
14530 }
14531
14532 func (e *Encoder) fastpathEncMapBoolIntR(f *codecFnInfo, rv reflect.Value) {
14533         fastpathTV.EncMapBoolIntV(rv2i(rv).(map[bool]int), e)
14534 }
14535 func (_ fastpathT) EncMapBoolIntV(v map[bool]int, e *Encoder) {
14536         if v == nil {
14537                 e.e.EncodeNil()
14538                 return
14539         }
14540         ee, esep := e.e, e.hh.hasElemSeparators()
14541         ee.WriteMapStart(len(v))
14542         if e.h.Canonical {
14543                 v2 := make([]bool, len(v))
14544                 var i int
14545                 for k, _ := range v {
14546                         v2[i] = bool(k)
14547                         i++
14548                 }
14549                 sort.Sort(boolSlice(v2))
14550                 if esep {
14551                         for _, k2 := range v2 {
14552                                 ee.WriteMapElemKey()
14553                                 ee.EncodeBool(bool(k2))
14554                                 ee.WriteMapElemValue()
14555                                 ee.EncodeInt(int64(v[bool(k2)]))
14556                         }
14557                 } else {
14558                         for _, k2 := range v2 {
14559                                 ee.EncodeBool(bool(k2))
14560                                 ee.EncodeInt(int64(v[bool(k2)]))
14561                         }
14562                 }
14563         } else {
14564                 if esep {
14565                         for k2, v2 := range v {
14566                                 ee.WriteMapElemKey()
14567                                 ee.EncodeBool(k2)
14568                                 ee.WriteMapElemValue()
14569                                 ee.EncodeInt(int64(v2))
14570                         }
14571                 } else {
14572                         for k2, v2 := range v {
14573                                 ee.EncodeBool(k2)
14574                                 ee.EncodeInt(int64(v2))
14575                         }
14576                 }
14577         }
14578         ee.WriteMapEnd()
14579 }
14580
14581 func (e *Encoder) fastpathEncMapBoolInt8R(f *codecFnInfo, rv reflect.Value) {
14582         fastpathTV.EncMapBoolInt8V(rv2i(rv).(map[bool]int8), e)
14583 }
14584 func (_ fastpathT) EncMapBoolInt8V(v map[bool]int8, e *Encoder) {
14585         if v == nil {
14586                 e.e.EncodeNil()
14587                 return
14588         }
14589         ee, esep := e.e, e.hh.hasElemSeparators()
14590         ee.WriteMapStart(len(v))
14591         if e.h.Canonical {
14592                 v2 := make([]bool, len(v))
14593                 var i int
14594                 for k, _ := range v {
14595                         v2[i] = bool(k)
14596                         i++
14597                 }
14598                 sort.Sort(boolSlice(v2))
14599                 if esep {
14600                         for _, k2 := range v2 {
14601                                 ee.WriteMapElemKey()
14602                                 ee.EncodeBool(bool(k2))
14603                                 ee.WriteMapElemValue()
14604                                 ee.EncodeInt(int64(v[bool(k2)]))
14605                         }
14606                 } else {
14607                         for _, k2 := range v2 {
14608                                 ee.EncodeBool(bool(k2))
14609                                 ee.EncodeInt(int64(v[bool(k2)]))
14610                         }
14611                 }
14612         } else {
14613                 if esep {
14614                         for k2, v2 := range v {
14615                                 ee.WriteMapElemKey()
14616                                 ee.EncodeBool(k2)
14617                                 ee.WriteMapElemValue()
14618                                 ee.EncodeInt(int64(v2))
14619                         }
14620                 } else {
14621                         for k2, v2 := range v {
14622                                 ee.EncodeBool(k2)
14623                                 ee.EncodeInt(int64(v2))
14624                         }
14625                 }
14626         }
14627         ee.WriteMapEnd()
14628 }
14629
14630 func (e *Encoder) fastpathEncMapBoolInt16R(f *codecFnInfo, rv reflect.Value) {
14631         fastpathTV.EncMapBoolInt16V(rv2i(rv).(map[bool]int16), e)
14632 }
14633 func (_ fastpathT) EncMapBoolInt16V(v map[bool]int16, e *Encoder) {
14634         if v == nil {
14635                 e.e.EncodeNil()
14636                 return
14637         }
14638         ee, esep := e.e, e.hh.hasElemSeparators()
14639         ee.WriteMapStart(len(v))
14640         if e.h.Canonical {
14641                 v2 := make([]bool, len(v))
14642                 var i int
14643                 for k, _ := range v {
14644                         v2[i] = bool(k)
14645                         i++
14646                 }
14647                 sort.Sort(boolSlice(v2))
14648                 if esep {
14649                         for _, k2 := range v2 {
14650                                 ee.WriteMapElemKey()
14651                                 ee.EncodeBool(bool(k2))
14652                                 ee.WriteMapElemValue()
14653                                 ee.EncodeInt(int64(v[bool(k2)]))
14654                         }
14655                 } else {
14656                         for _, k2 := range v2 {
14657                                 ee.EncodeBool(bool(k2))
14658                                 ee.EncodeInt(int64(v[bool(k2)]))
14659                         }
14660                 }
14661         } else {
14662                 if esep {
14663                         for k2, v2 := range v {
14664                                 ee.WriteMapElemKey()
14665                                 ee.EncodeBool(k2)
14666                                 ee.WriteMapElemValue()
14667                                 ee.EncodeInt(int64(v2))
14668                         }
14669                 } else {
14670                         for k2, v2 := range v {
14671                                 ee.EncodeBool(k2)
14672                                 ee.EncodeInt(int64(v2))
14673                         }
14674                 }
14675         }
14676         ee.WriteMapEnd()
14677 }
14678
14679 func (e *Encoder) fastpathEncMapBoolInt32R(f *codecFnInfo, rv reflect.Value) {
14680         fastpathTV.EncMapBoolInt32V(rv2i(rv).(map[bool]int32), e)
14681 }
14682 func (_ fastpathT) EncMapBoolInt32V(v map[bool]int32, e *Encoder) {
14683         if v == nil {
14684                 e.e.EncodeNil()
14685                 return
14686         }
14687         ee, esep := e.e, e.hh.hasElemSeparators()
14688         ee.WriteMapStart(len(v))
14689         if e.h.Canonical {
14690                 v2 := make([]bool, len(v))
14691                 var i int
14692                 for k, _ := range v {
14693                         v2[i] = bool(k)
14694                         i++
14695                 }
14696                 sort.Sort(boolSlice(v2))
14697                 if esep {
14698                         for _, k2 := range v2 {
14699                                 ee.WriteMapElemKey()
14700                                 ee.EncodeBool(bool(k2))
14701                                 ee.WriteMapElemValue()
14702                                 ee.EncodeInt(int64(v[bool(k2)]))
14703                         }
14704                 } else {
14705                         for _, k2 := range v2 {
14706                                 ee.EncodeBool(bool(k2))
14707                                 ee.EncodeInt(int64(v[bool(k2)]))
14708                         }
14709                 }
14710         } else {
14711                 if esep {
14712                         for k2, v2 := range v {
14713                                 ee.WriteMapElemKey()
14714                                 ee.EncodeBool(k2)
14715                                 ee.WriteMapElemValue()
14716                                 ee.EncodeInt(int64(v2))
14717                         }
14718                 } else {
14719                         for k2, v2 := range v {
14720                                 ee.EncodeBool(k2)
14721                                 ee.EncodeInt(int64(v2))
14722                         }
14723                 }
14724         }
14725         ee.WriteMapEnd()
14726 }
14727
14728 func (e *Encoder) fastpathEncMapBoolInt64R(f *codecFnInfo, rv reflect.Value) {
14729         fastpathTV.EncMapBoolInt64V(rv2i(rv).(map[bool]int64), e)
14730 }
14731 func (_ fastpathT) EncMapBoolInt64V(v map[bool]int64, e *Encoder) {
14732         if v == nil {
14733                 e.e.EncodeNil()
14734                 return
14735         }
14736         ee, esep := e.e, e.hh.hasElemSeparators()
14737         ee.WriteMapStart(len(v))
14738         if e.h.Canonical {
14739                 v2 := make([]bool, len(v))
14740                 var i int
14741                 for k, _ := range v {
14742                         v2[i] = bool(k)
14743                         i++
14744                 }
14745                 sort.Sort(boolSlice(v2))
14746                 if esep {
14747                         for _, k2 := range v2 {
14748                                 ee.WriteMapElemKey()
14749                                 ee.EncodeBool(bool(k2))
14750                                 ee.WriteMapElemValue()
14751                                 ee.EncodeInt(int64(v[bool(k2)]))
14752                         }
14753                 } else {
14754                         for _, k2 := range v2 {
14755                                 ee.EncodeBool(bool(k2))
14756                                 ee.EncodeInt(int64(v[bool(k2)]))
14757                         }
14758                 }
14759         } else {
14760                 if esep {
14761                         for k2, v2 := range v {
14762                                 ee.WriteMapElemKey()
14763                                 ee.EncodeBool(k2)
14764                                 ee.WriteMapElemValue()
14765                                 ee.EncodeInt(int64(v2))
14766                         }
14767                 } else {
14768                         for k2, v2 := range v {
14769                                 ee.EncodeBool(k2)
14770                                 ee.EncodeInt(int64(v2))
14771                         }
14772                 }
14773         }
14774         ee.WriteMapEnd()
14775 }
14776
14777 func (e *Encoder) fastpathEncMapBoolFloat32R(f *codecFnInfo, rv reflect.Value) {
14778         fastpathTV.EncMapBoolFloat32V(rv2i(rv).(map[bool]float32), e)
14779 }
14780 func (_ fastpathT) EncMapBoolFloat32V(v map[bool]float32, e *Encoder) {
14781         if v == nil {
14782                 e.e.EncodeNil()
14783                 return
14784         }
14785         ee, esep := e.e, e.hh.hasElemSeparators()
14786         ee.WriteMapStart(len(v))
14787         if e.h.Canonical {
14788                 v2 := make([]bool, len(v))
14789                 var i int
14790                 for k, _ := range v {
14791                         v2[i] = bool(k)
14792                         i++
14793                 }
14794                 sort.Sort(boolSlice(v2))
14795                 if esep {
14796                         for _, k2 := range v2 {
14797                                 ee.WriteMapElemKey()
14798                                 ee.EncodeBool(bool(k2))
14799                                 ee.WriteMapElemValue()
14800                                 ee.EncodeFloat32(v[bool(k2)])
14801                         }
14802                 } else {
14803                         for _, k2 := range v2 {
14804                                 ee.EncodeBool(bool(k2))
14805                                 ee.EncodeFloat32(v[bool(k2)])
14806                         }
14807                 }
14808         } else {
14809                 if esep {
14810                         for k2, v2 := range v {
14811                                 ee.WriteMapElemKey()
14812                                 ee.EncodeBool(k2)
14813                                 ee.WriteMapElemValue()
14814                                 ee.EncodeFloat32(v2)
14815                         }
14816                 } else {
14817                         for k2, v2 := range v {
14818                                 ee.EncodeBool(k2)
14819                                 ee.EncodeFloat32(v2)
14820                         }
14821                 }
14822         }
14823         ee.WriteMapEnd()
14824 }
14825
14826 func (e *Encoder) fastpathEncMapBoolFloat64R(f *codecFnInfo, rv reflect.Value) {
14827         fastpathTV.EncMapBoolFloat64V(rv2i(rv).(map[bool]float64), e)
14828 }
14829 func (_ fastpathT) EncMapBoolFloat64V(v map[bool]float64, e *Encoder) {
14830         if v == nil {
14831                 e.e.EncodeNil()
14832                 return
14833         }
14834         ee, esep := e.e, e.hh.hasElemSeparators()
14835         ee.WriteMapStart(len(v))
14836         if e.h.Canonical {
14837                 v2 := make([]bool, len(v))
14838                 var i int
14839                 for k, _ := range v {
14840                         v2[i] = bool(k)
14841                         i++
14842                 }
14843                 sort.Sort(boolSlice(v2))
14844                 if esep {
14845                         for _, k2 := range v2 {
14846                                 ee.WriteMapElemKey()
14847                                 ee.EncodeBool(bool(k2))
14848                                 ee.WriteMapElemValue()
14849                                 ee.EncodeFloat64(v[bool(k2)])
14850                         }
14851                 } else {
14852                         for _, k2 := range v2 {
14853                                 ee.EncodeBool(bool(k2))
14854                                 ee.EncodeFloat64(v[bool(k2)])
14855                         }
14856                 }
14857         } else {
14858                 if esep {
14859                         for k2, v2 := range v {
14860                                 ee.WriteMapElemKey()
14861                                 ee.EncodeBool(k2)
14862                                 ee.WriteMapElemValue()
14863                                 ee.EncodeFloat64(v2)
14864                         }
14865                 } else {
14866                         for k2, v2 := range v {
14867                                 ee.EncodeBool(k2)
14868                                 ee.EncodeFloat64(v2)
14869                         }
14870                 }
14871         }
14872         ee.WriteMapEnd()
14873 }
14874
14875 func (e *Encoder) fastpathEncMapBoolBoolR(f *codecFnInfo, rv reflect.Value) {
14876         fastpathTV.EncMapBoolBoolV(rv2i(rv).(map[bool]bool), e)
14877 }
14878 func (_ fastpathT) EncMapBoolBoolV(v map[bool]bool, e *Encoder) {
14879         if v == nil {
14880                 e.e.EncodeNil()
14881                 return
14882         }
14883         ee, esep := e.e, e.hh.hasElemSeparators()
14884         ee.WriteMapStart(len(v))
14885         if e.h.Canonical {
14886                 v2 := make([]bool, len(v))
14887                 var i int
14888                 for k, _ := range v {
14889                         v2[i] = bool(k)
14890                         i++
14891                 }
14892                 sort.Sort(boolSlice(v2))
14893                 if esep {
14894                         for _, k2 := range v2 {
14895                                 ee.WriteMapElemKey()
14896                                 ee.EncodeBool(bool(k2))
14897                                 ee.WriteMapElemValue()
14898                                 ee.EncodeBool(v[bool(k2)])
14899                         }
14900                 } else {
14901                         for _, k2 := range v2 {
14902                                 ee.EncodeBool(bool(k2))
14903                                 ee.EncodeBool(v[bool(k2)])
14904                         }
14905                 }
14906         } else {
14907                 if esep {
14908                         for k2, v2 := range v {
14909                                 ee.WriteMapElemKey()
14910                                 ee.EncodeBool(k2)
14911                                 ee.WriteMapElemValue()
14912                                 ee.EncodeBool(v2)
14913                         }
14914                 } else {
14915                         for k2, v2 := range v {
14916                                 ee.EncodeBool(k2)
14917                                 ee.EncodeBool(v2)
14918                         }
14919                 }
14920         }
14921         ee.WriteMapEnd()
14922 }
14923
14924 // -- decode
14925
14926 // -- -- fast path type switch
14927 func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool {
14928         var changed bool
14929         switch v := iv.(type) {
14930
14931         case []interface{}:
14932                 var v2 []interface{}
14933                 v2, changed = fastpathTV.DecSliceIntfV(v, false, d)
14934                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
14935                         copy(v, v2)
14936                 }
14937         case *[]interface{}:
14938                 var v2 []interface{}
14939                 v2, changed = fastpathTV.DecSliceIntfV(*v, true, d)
14940                 if changed {
14941                         *v = v2
14942                 }
14943         case []string:
14944                 var v2 []string
14945                 v2, changed = fastpathTV.DecSliceStringV(v, false, d)
14946                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
14947                         copy(v, v2)
14948                 }
14949         case *[]string:
14950                 var v2 []string
14951                 v2, changed = fastpathTV.DecSliceStringV(*v, true, d)
14952                 if changed {
14953                         *v = v2
14954                 }
14955         case []float32:
14956                 var v2 []float32
14957                 v2, changed = fastpathTV.DecSliceFloat32V(v, false, d)
14958                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
14959                         copy(v, v2)
14960                 }
14961         case *[]float32:
14962                 var v2 []float32
14963                 v2, changed = fastpathTV.DecSliceFloat32V(*v, true, d)
14964                 if changed {
14965                         *v = v2
14966                 }
14967         case []float64:
14968                 var v2 []float64
14969                 v2, changed = fastpathTV.DecSliceFloat64V(v, false, d)
14970                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
14971                         copy(v, v2)
14972                 }
14973         case *[]float64:
14974                 var v2 []float64
14975                 v2, changed = fastpathTV.DecSliceFloat64V(*v, true, d)
14976                 if changed {
14977                         *v = v2
14978                 }
14979         case []uint:
14980                 var v2 []uint
14981                 v2, changed = fastpathTV.DecSliceUintV(v, false, d)
14982                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
14983                         copy(v, v2)
14984                 }
14985         case *[]uint:
14986                 var v2 []uint
14987                 v2, changed = fastpathTV.DecSliceUintV(*v, true, d)
14988                 if changed {
14989                         *v = v2
14990                 }
14991         case []uint16:
14992                 var v2 []uint16
14993                 v2, changed = fastpathTV.DecSliceUint16V(v, false, d)
14994                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
14995                         copy(v, v2)
14996                 }
14997         case *[]uint16:
14998                 var v2 []uint16
14999                 v2, changed = fastpathTV.DecSliceUint16V(*v, true, d)
15000                 if changed {
15001                         *v = v2
15002                 }
15003         case []uint32:
15004                 var v2 []uint32
15005                 v2, changed = fastpathTV.DecSliceUint32V(v, false, d)
15006                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
15007                         copy(v, v2)
15008                 }
15009         case *[]uint32:
15010                 var v2 []uint32
15011                 v2, changed = fastpathTV.DecSliceUint32V(*v, true, d)
15012                 if changed {
15013                         *v = v2
15014                 }
15015         case []uint64:
15016                 var v2 []uint64
15017                 v2, changed = fastpathTV.DecSliceUint64V(v, false, d)
15018                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
15019                         copy(v, v2)
15020                 }
15021         case *[]uint64:
15022                 var v2 []uint64
15023                 v2, changed = fastpathTV.DecSliceUint64V(*v, true, d)
15024                 if changed {
15025                         *v = v2
15026                 }
15027         case []uintptr:
15028                 var v2 []uintptr
15029                 v2, changed = fastpathTV.DecSliceUintptrV(v, false, d)
15030                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
15031                         copy(v, v2)
15032                 }
15033         case *[]uintptr:
15034                 var v2 []uintptr
15035                 v2, changed = fastpathTV.DecSliceUintptrV(*v, true, d)
15036                 if changed {
15037                         *v = v2
15038                 }
15039         case []int:
15040                 var v2 []int
15041                 v2, changed = fastpathTV.DecSliceIntV(v, false, d)
15042                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
15043                         copy(v, v2)
15044                 }
15045         case *[]int:
15046                 var v2 []int
15047                 v2, changed = fastpathTV.DecSliceIntV(*v, true, d)
15048                 if changed {
15049                         *v = v2
15050                 }
15051         case []int8:
15052                 var v2 []int8
15053                 v2, changed = fastpathTV.DecSliceInt8V(v, false, d)
15054                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
15055                         copy(v, v2)
15056                 }
15057         case *[]int8:
15058                 var v2 []int8
15059                 v2, changed = fastpathTV.DecSliceInt8V(*v, true, d)
15060                 if changed {
15061                         *v = v2
15062                 }
15063         case []int16:
15064                 var v2 []int16
15065                 v2, changed = fastpathTV.DecSliceInt16V(v, false, d)
15066                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
15067                         copy(v, v2)
15068                 }
15069         case *[]int16:
15070                 var v2 []int16
15071                 v2, changed = fastpathTV.DecSliceInt16V(*v, true, d)
15072                 if changed {
15073                         *v = v2
15074                 }
15075         case []int32:
15076                 var v2 []int32
15077                 v2, changed = fastpathTV.DecSliceInt32V(v, false, d)
15078                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
15079                         copy(v, v2)
15080                 }
15081         case *[]int32:
15082                 var v2 []int32
15083                 v2, changed = fastpathTV.DecSliceInt32V(*v, true, d)
15084                 if changed {
15085                         *v = v2
15086                 }
15087         case []int64:
15088                 var v2 []int64
15089                 v2, changed = fastpathTV.DecSliceInt64V(v, false, d)
15090                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
15091                         copy(v, v2)
15092                 }
15093         case *[]int64:
15094                 var v2 []int64
15095                 v2, changed = fastpathTV.DecSliceInt64V(*v, true, d)
15096                 if changed {
15097                         *v = v2
15098                 }
15099         case []bool:
15100                 var v2 []bool
15101                 v2, changed = fastpathTV.DecSliceBoolV(v, false, d)
15102                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
15103                         copy(v, v2)
15104                 }
15105         case *[]bool:
15106                 var v2 []bool
15107                 v2, changed = fastpathTV.DecSliceBoolV(*v, true, d)
15108                 if changed {
15109                         *v = v2
15110                 }
15111
15112         case map[interface{}]interface{}:
15113                 fastpathTV.DecMapIntfIntfV(v, false, d)
15114         case *map[interface{}]interface{}:
15115                 var v2 map[interface{}]interface{}
15116                 v2, changed = fastpathTV.DecMapIntfIntfV(*v, true, d)
15117                 if changed {
15118                         *v = v2
15119                 }
15120         case map[interface{}]string:
15121                 fastpathTV.DecMapIntfStringV(v, false, d)
15122         case *map[interface{}]string:
15123                 var v2 map[interface{}]string
15124                 v2, changed = fastpathTV.DecMapIntfStringV(*v, true, d)
15125                 if changed {
15126                         *v = v2
15127                 }
15128         case map[interface{}]uint:
15129                 fastpathTV.DecMapIntfUintV(v, false, d)
15130         case *map[interface{}]uint:
15131                 var v2 map[interface{}]uint
15132                 v2, changed = fastpathTV.DecMapIntfUintV(*v, true, d)
15133                 if changed {
15134                         *v = v2
15135                 }
15136         case map[interface{}]uint8:
15137                 fastpathTV.DecMapIntfUint8V(v, false, d)
15138         case *map[interface{}]uint8:
15139                 var v2 map[interface{}]uint8
15140                 v2, changed = fastpathTV.DecMapIntfUint8V(*v, true, d)
15141                 if changed {
15142                         *v = v2
15143                 }
15144         case map[interface{}]uint16:
15145                 fastpathTV.DecMapIntfUint16V(v, false, d)
15146         case *map[interface{}]uint16:
15147                 var v2 map[interface{}]uint16
15148                 v2, changed = fastpathTV.DecMapIntfUint16V(*v, true, d)
15149                 if changed {
15150                         *v = v2
15151                 }
15152         case map[interface{}]uint32:
15153                 fastpathTV.DecMapIntfUint32V(v, false, d)
15154         case *map[interface{}]uint32:
15155                 var v2 map[interface{}]uint32
15156                 v2, changed = fastpathTV.DecMapIntfUint32V(*v, true, d)
15157                 if changed {
15158                         *v = v2
15159                 }
15160         case map[interface{}]uint64:
15161                 fastpathTV.DecMapIntfUint64V(v, false, d)
15162         case *map[interface{}]uint64:
15163                 var v2 map[interface{}]uint64
15164                 v2, changed = fastpathTV.DecMapIntfUint64V(*v, true, d)
15165                 if changed {
15166                         *v = v2
15167                 }
15168         case map[interface{}]uintptr:
15169                 fastpathTV.DecMapIntfUintptrV(v, false, d)
15170         case *map[interface{}]uintptr:
15171                 var v2 map[interface{}]uintptr
15172                 v2, changed = fastpathTV.DecMapIntfUintptrV(*v, true, d)
15173                 if changed {
15174                         *v = v2
15175                 }
15176         case map[interface{}]int:
15177                 fastpathTV.DecMapIntfIntV(v, false, d)
15178         case *map[interface{}]int:
15179                 var v2 map[interface{}]int
15180                 v2, changed = fastpathTV.DecMapIntfIntV(*v, true, d)
15181                 if changed {
15182                         *v = v2
15183                 }
15184         case map[interface{}]int8:
15185                 fastpathTV.DecMapIntfInt8V(v, false, d)
15186         case *map[interface{}]int8:
15187                 var v2 map[interface{}]int8
15188                 v2, changed = fastpathTV.DecMapIntfInt8V(*v, true, d)
15189                 if changed {
15190                         *v = v2
15191                 }
15192         case map[interface{}]int16:
15193                 fastpathTV.DecMapIntfInt16V(v, false, d)
15194         case *map[interface{}]int16:
15195                 var v2 map[interface{}]int16
15196                 v2, changed = fastpathTV.DecMapIntfInt16V(*v, true, d)
15197                 if changed {
15198                         *v = v2
15199                 }
15200         case map[interface{}]int32:
15201                 fastpathTV.DecMapIntfInt32V(v, false, d)
15202         case *map[interface{}]int32:
15203                 var v2 map[interface{}]int32
15204                 v2, changed = fastpathTV.DecMapIntfInt32V(*v, true, d)
15205                 if changed {
15206                         *v = v2
15207                 }
15208         case map[interface{}]int64:
15209                 fastpathTV.DecMapIntfInt64V(v, false, d)
15210         case *map[interface{}]int64:
15211                 var v2 map[interface{}]int64
15212                 v2, changed = fastpathTV.DecMapIntfInt64V(*v, true, d)
15213                 if changed {
15214                         *v = v2
15215                 }
15216         case map[interface{}]float32:
15217                 fastpathTV.DecMapIntfFloat32V(v, false, d)
15218         case *map[interface{}]float32:
15219                 var v2 map[interface{}]float32
15220                 v2, changed = fastpathTV.DecMapIntfFloat32V(*v, true, d)
15221                 if changed {
15222                         *v = v2
15223                 }
15224         case map[interface{}]float64:
15225                 fastpathTV.DecMapIntfFloat64V(v, false, d)
15226         case *map[interface{}]float64:
15227                 var v2 map[interface{}]float64
15228                 v2, changed = fastpathTV.DecMapIntfFloat64V(*v, true, d)
15229                 if changed {
15230                         *v = v2
15231                 }
15232         case map[interface{}]bool:
15233                 fastpathTV.DecMapIntfBoolV(v, false, d)
15234         case *map[interface{}]bool:
15235                 var v2 map[interface{}]bool
15236                 v2, changed = fastpathTV.DecMapIntfBoolV(*v, true, d)
15237                 if changed {
15238                         *v = v2
15239                 }
15240         case map[string]interface{}:
15241                 fastpathTV.DecMapStringIntfV(v, false, d)
15242         case *map[string]interface{}:
15243                 var v2 map[string]interface{}
15244                 v2, changed = fastpathTV.DecMapStringIntfV(*v, true, d)
15245                 if changed {
15246                         *v = v2
15247                 }
15248         case map[string]string:
15249                 fastpathTV.DecMapStringStringV(v, false, d)
15250         case *map[string]string:
15251                 var v2 map[string]string
15252                 v2, changed = fastpathTV.DecMapStringStringV(*v, true, d)
15253                 if changed {
15254                         *v = v2
15255                 }
15256         case map[string]uint:
15257                 fastpathTV.DecMapStringUintV(v, false, d)
15258         case *map[string]uint:
15259                 var v2 map[string]uint
15260                 v2, changed = fastpathTV.DecMapStringUintV(*v, true, d)
15261                 if changed {
15262                         *v = v2
15263                 }
15264         case map[string]uint8:
15265                 fastpathTV.DecMapStringUint8V(v, false, d)
15266         case *map[string]uint8:
15267                 var v2 map[string]uint8
15268                 v2, changed = fastpathTV.DecMapStringUint8V(*v, true, d)
15269                 if changed {
15270                         *v = v2
15271                 }
15272         case map[string]uint16:
15273                 fastpathTV.DecMapStringUint16V(v, false, d)
15274         case *map[string]uint16:
15275                 var v2 map[string]uint16
15276                 v2, changed = fastpathTV.DecMapStringUint16V(*v, true, d)
15277                 if changed {
15278                         *v = v2
15279                 }
15280         case map[string]uint32:
15281                 fastpathTV.DecMapStringUint32V(v, false, d)
15282         case *map[string]uint32:
15283                 var v2 map[string]uint32
15284                 v2, changed = fastpathTV.DecMapStringUint32V(*v, true, d)
15285                 if changed {
15286                         *v = v2
15287                 }
15288         case map[string]uint64:
15289                 fastpathTV.DecMapStringUint64V(v, false, d)
15290         case *map[string]uint64:
15291                 var v2 map[string]uint64
15292                 v2, changed = fastpathTV.DecMapStringUint64V(*v, true, d)
15293                 if changed {
15294                         *v = v2
15295                 }
15296         case map[string]uintptr:
15297                 fastpathTV.DecMapStringUintptrV(v, false, d)
15298         case *map[string]uintptr:
15299                 var v2 map[string]uintptr
15300                 v2, changed = fastpathTV.DecMapStringUintptrV(*v, true, d)
15301                 if changed {
15302                         *v = v2
15303                 }
15304         case map[string]int:
15305                 fastpathTV.DecMapStringIntV(v, false, d)
15306         case *map[string]int:
15307                 var v2 map[string]int
15308                 v2, changed = fastpathTV.DecMapStringIntV(*v, true, d)
15309                 if changed {
15310                         *v = v2
15311                 }
15312         case map[string]int8:
15313                 fastpathTV.DecMapStringInt8V(v, false, d)
15314         case *map[string]int8:
15315                 var v2 map[string]int8
15316                 v2, changed = fastpathTV.DecMapStringInt8V(*v, true, d)
15317                 if changed {
15318                         *v = v2
15319                 }
15320         case map[string]int16:
15321                 fastpathTV.DecMapStringInt16V(v, false, d)
15322         case *map[string]int16:
15323                 var v2 map[string]int16
15324                 v2, changed = fastpathTV.DecMapStringInt16V(*v, true, d)
15325                 if changed {
15326                         *v = v2
15327                 }
15328         case map[string]int32:
15329                 fastpathTV.DecMapStringInt32V(v, false, d)
15330         case *map[string]int32:
15331                 var v2 map[string]int32
15332                 v2, changed = fastpathTV.DecMapStringInt32V(*v, true, d)
15333                 if changed {
15334                         *v = v2
15335                 }
15336         case map[string]int64:
15337                 fastpathTV.DecMapStringInt64V(v, false, d)
15338         case *map[string]int64:
15339                 var v2 map[string]int64
15340                 v2, changed = fastpathTV.DecMapStringInt64V(*v, true, d)
15341                 if changed {
15342                         *v = v2
15343                 }
15344         case map[string]float32:
15345                 fastpathTV.DecMapStringFloat32V(v, false, d)
15346         case *map[string]float32:
15347                 var v2 map[string]float32
15348                 v2, changed = fastpathTV.DecMapStringFloat32V(*v, true, d)
15349                 if changed {
15350                         *v = v2
15351                 }
15352         case map[string]float64:
15353                 fastpathTV.DecMapStringFloat64V(v, false, d)
15354         case *map[string]float64:
15355                 var v2 map[string]float64
15356                 v2, changed = fastpathTV.DecMapStringFloat64V(*v, true, d)
15357                 if changed {
15358                         *v = v2
15359                 }
15360         case map[string]bool:
15361                 fastpathTV.DecMapStringBoolV(v, false, d)
15362         case *map[string]bool:
15363                 var v2 map[string]bool
15364                 v2, changed = fastpathTV.DecMapStringBoolV(*v, true, d)
15365                 if changed {
15366                         *v = v2
15367                 }
15368         case map[float32]interface{}:
15369                 fastpathTV.DecMapFloat32IntfV(v, false, d)
15370         case *map[float32]interface{}:
15371                 var v2 map[float32]interface{}
15372                 v2, changed = fastpathTV.DecMapFloat32IntfV(*v, true, d)
15373                 if changed {
15374                         *v = v2
15375                 }
15376         case map[float32]string:
15377                 fastpathTV.DecMapFloat32StringV(v, false, d)
15378         case *map[float32]string:
15379                 var v2 map[float32]string
15380                 v2, changed = fastpathTV.DecMapFloat32StringV(*v, true, d)
15381                 if changed {
15382                         *v = v2
15383                 }
15384         case map[float32]uint:
15385                 fastpathTV.DecMapFloat32UintV(v, false, d)
15386         case *map[float32]uint:
15387                 var v2 map[float32]uint
15388                 v2, changed = fastpathTV.DecMapFloat32UintV(*v, true, d)
15389                 if changed {
15390                         *v = v2
15391                 }
15392         case map[float32]uint8:
15393                 fastpathTV.DecMapFloat32Uint8V(v, false, d)
15394         case *map[float32]uint8:
15395                 var v2 map[float32]uint8
15396                 v2, changed = fastpathTV.DecMapFloat32Uint8V(*v, true, d)
15397                 if changed {
15398                         *v = v2
15399                 }
15400         case map[float32]uint16:
15401                 fastpathTV.DecMapFloat32Uint16V(v, false, d)
15402         case *map[float32]uint16:
15403                 var v2 map[float32]uint16
15404                 v2, changed = fastpathTV.DecMapFloat32Uint16V(*v, true, d)
15405                 if changed {
15406                         *v = v2
15407                 }
15408         case map[float32]uint32:
15409                 fastpathTV.DecMapFloat32Uint32V(v, false, d)
15410         case *map[float32]uint32:
15411                 var v2 map[float32]uint32
15412                 v2, changed = fastpathTV.DecMapFloat32Uint32V(*v, true, d)
15413                 if changed {
15414                         *v = v2
15415                 }
15416         case map[float32]uint64:
15417                 fastpathTV.DecMapFloat32Uint64V(v, false, d)
15418         case *map[float32]uint64:
15419                 var v2 map[float32]uint64
15420                 v2, changed = fastpathTV.DecMapFloat32Uint64V(*v, true, d)
15421                 if changed {
15422                         *v = v2
15423                 }
15424         case map[float32]uintptr:
15425                 fastpathTV.DecMapFloat32UintptrV(v, false, d)
15426         case *map[float32]uintptr:
15427                 var v2 map[float32]uintptr
15428                 v2, changed = fastpathTV.DecMapFloat32UintptrV(*v, true, d)
15429                 if changed {
15430                         *v = v2
15431                 }
15432         case map[float32]int:
15433                 fastpathTV.DecMapFloat32IntV(v, false, d)
15434         case *map[float32]int:
15435                 var v2 map[float32]int
15436                 v2, changed = fastpathTV.DecMapFloat32IntV(*v, true, d)
15437                 if changed {
15438                         *v = v2
15439                 }
15440         case map[float32]int8:
15441                 fastpathTV.DecMapFloat32Int8V(v, false, d)
15442         case *map[float32]int8:
15443                 var v2 map[float32]int8
15444                 v2, changed = fastpathTV.DecMapFloat32Int8V(*v, true, d)
15445                 if changed {
15446                         *v = v2
15447                 }
15448         case map[float32]int16:
15449                 fastpathTV.DecMapFloat32Int16V(v, false, d)
15450         case *map[float32]int16:
15451                 var v2 map[float32]int16
15452                 v2, changed = fastpathTV.DecMapFloat32Int16V(*v, true, d)
15453                 if changed {
15454                         *v = v2
15455                 }
15456         case map[float32]int32:
15457                 fastpathTV.DecMapFloat32Int32V(v, false, d)
15458         case *map[float32]int32:
15459                 var v2 map[float32]int32
15460                 v2, changed = fastpathTV.DecMapFloat32Int32V(*v, true, d)
15461                 if changed {
15462                         *v = v2
15463                 }
15464         case map[float32]int64:
15465                 fastpathTV.DecMapFloat32Int64V(v, false, d)
15466         case *map[float32]int64:
15467                 var v2 map[float32]int64
15468                 v2, changed = fastpathTV.DecMapFloat32Int64V(*v, true, d)
15469                 if changed {
15470                         *v = v2
15471                 }
15472         case map[float32]float32:
15473                 fastpathTV.DecMapFloat32Float32V(v, false, d)
15474         case *map[float32]float32:
15475                 var v2 map[float32]float32
15476                 v2, changed = fastpathTV.DecMapFloat32Float32V(*v, true, d)
15477                 if changed {
15478                         *v = v2
15479                 }
15480         case map[float32]float64:
15481                 fastpathTV.DecMapFloat32Float64V(v, false, d)
15482         case *map[float32]float64:
15483                 var v2 map[float32]float64
15484                 v2, changed = fastpathTV.DecMapFloat32Float64V(*v, true, d)
15485                 if changed {
15486                         *v = v2
15487                 }
15488         case map[float32]bool:
15489                 fastpathTV.DecMapFloat32BoolV(v, false, d)
15490         case *map[float32]bool:
15491                 var v2 map[float32]bool
15492                 v2, changed = fastpathTV.DecMapFloat32BoolV(*v, true, d)
15493                 if changed {
15494                         *v = v2
15495                 }
15496         case map[float64]interface{}:
15497                 fastpathTV.DecMapFloat64IntfV(v, false, d)
15498         case *map[float64]interface{}:
15499                 var v2 map[float64]interface{}
15500                 v2, changed = fastpathTV.DecMapFloat64IntfV(*v, true, d)
15501                 if changed {
15502                         *v = v2
15503                 }
15504         case map[float64]string:
15505                 fastpathTV.DecMapFloat64StringV(v, false, d)
15506         case *map[float64]string:
15507                 var v2 map[float64]string
15508                 v2, changed = fastpathTV.DecMapFloat64StringV(*v, true, d)
15509                 if changed {
15510                         *v = v2
15511                 }
15512         case map[float64]uint:
15513                 fastpathTV.DecMapFloat64UintV(v, false, d)
15514         case *map[float64]uint:
15515                 var v2 map[float64]uint
15516                 v2, changed = fastpathTV.DecMapFloat64UintV(*v, true, d)
15517                 if changed {
15518                         *v = v2
15519                 }
15520         case map[float64]uint8:
15521                 fastpathTV.DecMapFloat64Uint8V(v, false, d)
15522         case *map[float64]uint8:
15523                 var v2 map[float64]uint8
15524                 v2, changed = fastpathTV.DecMapFloat64Uint8V(*v, true, d)
15525                 if changed {
15526                         *v = v2
15527                 }
15528         case map[float64]uint16:
15529                 fastpathTV.DecMapFloat64Uint16V(v, false, d)
15530         case *map[float64]uint16:
15531                 var v2 map[float64]uint16
15532                 v2, changed = fastpathTV.DecMapFloat64Uint16V(*v, true, d)
15533                 if changed {
15534                         *v = v2
15535                 }
15536         case map[float64]uint32:
15537                 fastpathTV.DecMapFloat64Uint32V(v, false, d)
15538         case *map[float64]uint32:
15539                 var v2 map[float64]uint32
15540                 v2, changed = fastpathTV.DecMapFloat64Uint32V(*v, true, d)
15541                 if changed {
15542                         *v = v2
15543                 }
15544         case map[float64]uint64:
15545                 fastpathTV.DecMapFloat64Uint64V(v, false, d)
15546         case *map[float64]uint64:
15547                 var v2 map[float64]uint64
15548                 v2, changed = fastpathTV.DecMapFloat64Uint64V(*v, true, d)
15549                 if changed {
15550                         *v = v2
15551                 }
15552         case map[float64]uintptr:
15553                 fastpathTV.DecMapFloat64UintptrV(v, false, d)
15554         case *map[float64]uintptr:
15555                 var v2 map[float64]uintptr
15556                 v2, changed = fastpathTV.DecMapFloat64UintptrV(*v, true, d)
15557                 if changed {
15558                         *v = v2
15559                 }
15560         case map[float64]int:
15561                 fastpathTV.DecMapFloat64IntV(v, false, d)
15562         case *map[float64]int:
15563                 var v2 map[float64]int
15564                 v2, changed = fastpathTV.DecMapFloat64IntV(*v, true, d)
15565                 if changed {
15566                         *v = v2
15567                 }
15568         case map[float64]int8:
15569                 fastpathTV.DecMapFloat64Int8V(v, false, d)
15570         case *map[float64]int8:
15571                 var v2 map[float64]int8
15572                 v2, changed = fastpathTV.DecMapFloat64Int8V(*v, true, d)
15573                 if changed {
15574                         *v = v2
15575                 }
15576         case map[float64]int16:
15577                 fastpathTV.DecMapFloat64Int16V(v, false, d)
15578         case *map[float64]int16:
15579                 var v2 map[float64]int16
15580                 v2, changed = fastpathTV.DecMapFloat64Int16V(*v, true, d)
15581                 if changed {
15582                         *v = v2
15583                 }
15584         case map[float64]int32:
15585                 fastpathTV.DecMapFloat64Int32V(v, false, d)
15586         case *map[float64]int32:
15587                 var v2 map[float64]int32
15588                 v2, changed = fastpathTV.DecMapFloat64Int32V(*v, true, d)
15589                 if changed {
15590                         *v = v2
15591                 }
15592         case map[float64]int64:
15593                 fastpathTV.DecMapFloat64Int64V(v, false, d)
15594         case *map[float64]int64:
15595                 var v2 map[float64]int64
15596                 v2, changed = fastpathTV.DecMapFloat64Int64V(*v, true, d)
15597                 if changed {
15598                         *v = v2
15599                 }
15600         case map[float64]float32:
15601                 fastpathTV.DecMapFloat64Float32V(v, false, d)
15602         case *map[float64]float32:
15603                 var v2 map[float64]float32
15604                 v2, changed = fastpathTV.DecMapFloat64Float32V(*v, true, d)
15605                 if changed {
15606                         *v = v2
15607                 }
15608         case map[float64]float64:
15609                 fastpathTV.DecMapFloat64Float64V(v, false, d)
15610         case *map[float64]float64:
15611                 var v2 map[float64]float64
15612                 v2, changed = fastpathTV.DecMapFloat64Float64V(*v, true, d)
15613                 if changed {
15614                         *v = v2
15615                 }
15616         case map[float64]bool:
15617                 fastpathTV.DecMapFloat64BoolV(v, false, d)
15618         case *map[float64]bool:
15619                 var v2 map[float64]bool
15620                 v2, changed = fastpathTV.DecMapFloat64BoolV(*v, true, d)
15621                 if changed {
15622                         *v = v2
15623                 }
15624         case map[uint]interface{}:
15625                 fastpathTV.DecMapUintIntfV(v, false, d)
15626         case *map[uint]interface{}:
15627                 var v2 map[uint]interface{}
15628                 v2, changed = fastpathTV.DecMapUintIntfV(*v, true, d)
15629                 if changed {
15630                         *v = v2
15631                 }
15632         case map[uint]string:
15633                 fastpathTV.DecMapUintStringV(v, false, d)
15634         case *map[uint]string:
15635                 var v2 map[uint]string
15636                 v2, changed = fastpathTV.DecMapUintStringV(*v, true, d)
15637                 if changed {
15638                         *v = v2
15639                 }
15640         case map[uint]uint:
15641                 fastpathTV.DecMapUintUintV(v, false, d)
15642         case *map[uint]uint:
15643                 var v2 map[uint]uint
15644                 v2, changed = fastpathTV.DecMapUintUintV(*v, true, d)
15645                 if changed {
15646                         *v = v2
15647                 }
15648         case map[uint]uint8:
15649                 fastpathTV.DecMapUintUint8V(v, false, d)
15650         case *map[uint]uint8:
15651                 var v2 map[uint]uint8
15652                 v2, changed = fastpathTV.DecMapUintUint8V(*v, true, d)
15653                 if changed {
15654                         *v = v2
15655                 }
15656         case map[uint]uint16:
15657                 fastpathTV.DecMapUintUint16V(v, false, d)
15658         case *map[uint]uint16:
15659                 var v2 map[uint]uint16
15660                 v2, changed = fastpathTV.DecMapUintUint16V(*v, true, d)
15661                 if changed {
15662                         *v = v2
15663                 }
15664         case map[uint]uint32:
15665                 fastpathTV.DecMapUintUint32V(v, false, d)
15666         case *map[uint]uint32:
15667                 var v2 map[uint]uint32
15668                 v2, changed = fastpathTV.DecMapUintUint32V(*v, true, d)
15669                 if changed {
15670                         *v = v2
15671                 }
15672         case map[uint]uint64:
15673                 fastpathTV.DecMapUintUint64V(v, false, d)
15674         case *map[uint]uint64:
15675                 var v2 map[uint]uint64
15676                 v2, changed = fastpathTV.DecMapUintUint64V(*v, true, d)
15677                 if changed {
15678                         *v = v2
15679                 }
15680         case map[uint]uintptr:
15681                 fastpathTV.DecMapUintUintptrV(v, false, d)
15682         case *map[uint]uintptr:
15683                 var v2 map[uint]uintptr
15684                 v2, changed = fastpathTV.DecMapUintUintptrV(*v, true, d)
15685                 if changed {
15686                         *v = v2
15687                 }
15688         case map[uint]int:
15689                 fastpathTV.DecMapUintIntV(v, false, d)
15690         case *map[uint]int:
15691                 var v2 map[uint]int
15692                 v2, changed = fastpathTV.DecMapUintIntV(*v, true, d)
15693                 if changed {
15694                         *v = v2
15695                 }
15696         case map[uint]int8:
15697                 fastpathTV.DecMapUintInt8V(v, false, d)
15698         case *map[uint]int8:
15699                 var v2 map[uint]int8
15700                 v2, changed = fastpathTV.DecMapUintInt8V(*v, true, d)
15701                 if changed {
15702                         *v = v2
15703                 }
15704         case map[uint]int16:
15705                 fastpathTV.DecMapUintInt16V(v, false, d)
15706         case *map[uint]int16:
15707                 var v2 map[uint]int16
15708                 v2, changed = fastpathTV.DecMapUintInt16V(*v, true, d)
15709                 if changed {
15710                         *v = v2
15711                 }
15712         case map[uint]int32:
15713                 fastpathTV.DecMapUintInt32V(v, false, d)
15714         case *map[uint]int32:
15715                 var v2 map[uint]int32
15716                 v2, changed = fastpathTV.DecMapUintInt32V(*v, true, d)
15717                 if changed {
15718                         *v = v2
15719                 }
15720         case map[uint]int64:
15721                 fastpathTV.DecMapUintInt64V(v, false, d)
15722         case *map[uint]int64:
15723                 var v2 map[uint]int64
15724                 v2, changed = fastpathTV.DecMapUintInt64V(*v, true, d)
15725                 if changed {
15726                         *v = v2
15727                 }
15728         case map[uint]float32:
15729                 fastpathTV.DecMapUintFloat32V(v, false, d)
15730         case *map[uint]float32:
15731                 var v2 map[uint]float32
15732                 v2, changed = fastpathTV.DecMapUintFloat32V(*v, true, d)
15733                 if changed {
15734                         *v = v2
15735                 }
15736         case map[uint]float64:
15737                 fastpathTV.DecMapUintFloat64V(v, false, d)
15738         case *map[uint]float64:
15739                 var v2 map[uint]float64
15740                 v2, changed = fastpathTV.DecMapUintFloat64V(*v, true, d)
15741                 if changed {
15742                         *v = v2
15743                 }
15744         case map[uint]bool:
15745                 fastpathTV.DecMapUintBoolV(v, false, d)
15746         case *map[uint]bool:
15747                 var v2 map[uint]bool
15748                 v2, changed = fastpathTV.DecMapUintBoolV(*v, true, d)
15749                 if changed {
15750                         *v = v2
15751                 }
15752         case map[uint8]interface{}:
15753                 fastpathTV.DecMapUint8IntfV(v, false, d)
15754         case *map[uint8]interface{}:
15755                 var v2 map[uint8]interface{}
15756                 v2, changed = fastpathTV.DecMapUint8IntfV(*v, true, d)
15757                 if changed {
15758                         *v = v2
15759                 }
15760         case map[uint8]string:
15761                 fastpathTV.DecMapUint8StringV(v, false, d)
15762         case *map[uint8]string:
15763                 var v2 map[uint8]string
15764                 v2, changed = fastpathTV.DecMapUint8StringV(*v, true, d)
15765                 if changed {
15766                         *v = v2
15767                 }
15768         case map[uint8]uint:
15769                 fastpathTV.DecMapUint8UintV(v, false, d)
15770         case *map[uint8]uint:
15771                 var v2 map[uint8]uint
15772                 v2, changed = fastpathTV.DecMapUint8UintV(*v, true, d)
15773                 if changed {
15774                         *v = v2
15775                 }
15776         case map[uint8]uint8:
15777                 fastpathTV.DecMapUint8Uint8V(v, false, d)
15778         case *map[uint8]uint8:
15779                 var v2 map[uint8]uint8
15780                 v2, changed = fastpathTV.DecMapUint8Uint8V(*v, true, d)
15781                 if changed {
15782                         *v = v2
15783                 }
15784         case map[uint8]uint16:
15785                 fastpathTV.DecMapUint8Uint16V(v, false, d)
15786         case *map[uint8]uint16:
15787                 var v2 map[uint8]uint16
15788                 v2, changed = fastpathTV.DecMapUint8Uint16V(*v, true, d)
15789                 if changed {
15790                         *v = v2
15791                 }
15792         case map[uint8]uint32:
15793                 fastpathTV.DecMapUint8Uint32V(v, false, d)
15794         case *map[uint8]uint32:
15795                 var v2 map[uint8]uint32
15796                 v2, changed = fastpathTV.DecMapUint8Uint32V(*v, true, d)
15797                 if changed {
15798                         *v = v2
15799                 }
15800         case map[uint8]uint64:
15801                 fastpathTV.DecMapUint8Uint64V(v, false, d)
15802         case *map[uint8]uint64:
15803                 var v2 map[uint8]uint64
15804                 v2, changed = fastpathTV.DecMapUint8Uint64V(*v, true, d)
15805                 if changed {
15806                         *v = v2
15807                 }
15808         case map[uint8]uintptr:
15809                 fastpathTV.DecMapUint8UintptrV(v, false, d)
15810         case *map[uint8]uintptr:
15811                 var v2 map[uint8]uintptr
15812                 v2, changed = fastpathTV.DecMapUint8UintptrV(*v, true, d)
15813                 if changed {
15814                         *v = v2
15815                 }
15816         case map[uint8]int:
15817                 fastpathTV.DecMapUint8IntV(v, false, d)
15818         case *map[uint8]int:
15819                 var v2 map[uint8]int
15820                 v2, changed = fastpathTV.DecMapUint8IntV(*v, true, d)
15821                 if changed {
15822                         *v = v2
15823                 }
15824         case map[uint8]int8:
15825                 fastpathTV.DecMapUint8Int8V(v, false, d)
15826         case *map[uint8]int8:
15827                 var v2 map[uint8]int8
15828                 v2, changed = fastpathTV.DecMapUint8Int8V(*v, true, d)
15829                 if changed {
15830                         *v = v2
15831                 }
15832         case map[uint8]int16:
15833                 fastpathTV.DecMapUint8Int16V(v, false, d)
15834         case *map[uint8]int16:
15835                 var v2 map[uint8]int16
15836                 v2, changed = fastpathTV.DecMapUint8Int16V(*v, true, d)
15837                 if changed {
15838                         *v = v2
15839                 }
15840         case map[uint8]int32:
15841                 fastpathTV.DecMapUint8Int32V(v, false, d)
15842         case *map[uint8]int32:
15843                 var v2 map[uint8]int32
15844                 v2, changed = fastpathTV.DecMapUint8Int32V(*v, true, d)
15845                 if changed {
15846                         *v = v2
15847                 }
15848         case map[uint8]int64:
15849                 fastpathTV.DecMapUint8Int64V(v, false, d)
15850         case *map[uint8]int64:
15851                 var v2 map[uint8]int64
15852                 v2, changed = fastpathTV.DecMapUint8Int64V(*v, true, d)
15853                 if changed {
15854                         *v = v2
15855                 }
15856         case map[uint8]float32:
15857                 fastpathTV.DecMapUint8Float32V(v, false, d)
15858         case *map[uint8]float32:
15859                 var v2 map[uint8]float32
15860                 v2, changed = fastpathTV.DecMapUint8Float32V(*v, true, d)
15861                 if changed {
15862                         *v = v2
15863                 }
15864         case map[uint8]float64:
15865                 fastpathTV.DecMapUint8Float64V(v, false, d)
15866         case *map[uint8]float64:
15867                 var v2 map[uint8]float64
15868                 v2, changed = fastpathTV.DecMapUint8Float64V(*v, true, d)
15869                 if changed {
15870                         *v = v2
15871                 }
15872         case map[uint8]bool:
15873                 fastpathTV.DecMapUint8BoolV(v, false, d)
15874         case *map[uint8]bool:
15875                 var v2 map[uint8]bool
15876                 v2, changed = fastpathTV.DecMapUint8BoolV(*v, true, d)
15877                 if changed {
15878                         *v = v2
15879                 }
15880         case map[uint16]interface{}:
15881                 fastpathTV.DecMapUint16IntfV(v, false, d)
15882         case *map[uint16]interface{}:
15883                 var v2 map[uint16]interface{}
15884                 v2, changed = fastpathTV.DecMapUint16IntfV(*v, true, d)
15885                 if changed {
15886                         *v = v2
15887                 }
15888         case map[uint16]string:
15889                 fastpathTV.DecMapUint16StringV(v, false, d)
15890         case *map[uint16]string:
15891                 var v2 map[uint16]string
15892                 v2, changed = fastpathTV.DecMapUint16StringV(*v, true, d)
15893                 if changed {
15894                         *v = v2
15895                 }
15896         case map[uint16]uint:
15897                 fastpathTV.DecMapUint16UintV(v, false, d)
15898         case *map[uint16]uint:
15899                 var v2 map[uint16]uint
15900                 v2, changed = fastpathTV.DecMapUint16UintV(*v, true, d)
15901                 if changed {
15902                         *v = v2
15903                 }
15904         case map[uint16]uint8:
15905                 fastpathTV.DecMapUint16Uint8V(v, false, d)
15906         case *map[uint16]uint8:
15907                 var v2 map[uint16]uint8
15908                 v2, changed = fastpathTV.DecMapUint16Uint8V(*v, true, d)
15909                 if changed {
15910                         *v = v2
15911                 }
15912         case map[uint16]uint16:
15913                 fastpathTV.DecMapUint16Uint16V(v, false, d)
15914         case *map[uint16]uint16:
15915                 var v2 map[uint16]uint16
15916                 v2, changed = fastpathTV.DecMapUint16Uint16V(*v, true, d)
15917                 if changed {
15918                         *v = v2
15919                 }
15920         case map[uint16]uint32:
15921                 fastpathTV.DecMapUint16Uint32V(v, false, d)
15922         case *map[uint16]uint32:
15923                 var v2 map[uint16]uint32
15924                 v2, changed = fastpathTV.DecMapUint16Uint32V(*v, true, d)
15925                 if changed {
15926                         *v = v2
15927                 }
15928         case map[uint16]uint64:
15929                 fastpathTV.DecMapUint16Uint64V(v, false, d)
15930         case *map[uint16]uint64:
15931                 var v2 map[uint16]uint64
15932                 v2, changed = fastpathTV.DecMapUint16Uint64V(*v, true, d)
15933                 if changed {
15934                         *v = v2
15935                 }
15936         case map[uint16]uintptr:
15937                 fastpathTV.DecMapUint16UintptrV(v, false, d)
15938         case *map[uint16]uintptr:
15939                 var v2 map[uint16]uintptr
15940                 v2, changed = fastpathTV.DecMapUint16UintptrV(*v, true, d)
15941                 if changed {
15942                         *v = v2
15943                 }
15944         case map[uint16]int:
15945                 fastpathTV.DecMapUint16IntV(v, false, d)
15946         case *map[uint16]int:
15947                 var v2 map[uint16]int
15948                 v2, changed = fastpathTV.DecMapUint16IntV(*v, true, d)
15949                 if changed {
15950                         *v = v2
15951                 }
15952         case map[uint16]int8:
15953                 fastpathTV.DecMapUint16Int8V(v, false, d)
15954         case *map[uint16]int8:
15955                 var v2 map[uint16]int8
15956                 v2, changed = fastpathTV.DecMapUint16Int8V(*v, true, d)
15957                 if changed {
15958                         *v = v2
15959                 }
15960         case map[uint16]int16:
15961                 fastpathTV.DecMapUint16Int16V(v, false, d)
15962         case *map[uint16]int16:
15963                 var v2 map[uint16]int16
15964                 v2, changed = fastpathTV.DecMapUint16Int16V(*v, true, d)
15965                 if changed {
15966                         *v = v2
15967                 }
15968         case map[uint16]int32:
15969                 fastpathTV.DecMapUint16Int32V(v, false, d)
15970         case *map[uint16]int32:
15971                 var v2 map[uint16]int32
15972                 v2, changed = fastpathTV.DecMapUint16Int32V(*v, true, d)
15973                 if changed {
15974                         *v = v2
15975                 }
15976         case map[uint16]int64:
15977                 fastpathTV.DecMapUint16Int64V(v, false, d)
15978         case *map[uint16]int64:
15979                 var v2 map[uint16]int64
15980                 v2, changed = fastpathTV.DecMapUint16Int64V(*v, true, d)
15981                 if changed {
15982                         *v = v2
15983                 }
15984         case map[uint16]float32:
15985                 fastpathTV.DecMapUint16Float32V(v, false, d)
15986         case *map[uint16]float32:
15987                 var v2 map[uint16]float32
15988                 v2, changed = fastpathTV.DecMapUint16Float32V(*v, true, d)
15989                 if changed {
15990                         *v = v2
15991                 }
15992         case map[uint16]float64:
15993                 fastpathTV.DecMapUint16Float64V(v, false, d)
15994         case *map[uint16]float64:
15995                 var v2 map[uint16]float64
15996                 v2, changed = fastpathTV.DecMapUint16Float64V(*v, true, d)
15997                 if changed {
15998                         *v = v2
15999                 }
16000         case map[uint16]bool:
16001                 fastpathTV.DecMapUint16BoolV(v, false, d)
16002         case *map[uint16]bool:
16003                 var v2 map[uint16]bool
16004                 v2, changed = fastpathTV.DecMapUint16BoolV(*v, true, d)
16005                 if changed {
16006                         *v = v2
16007                 }
16008         case map[uint32]interface{}:
16009                 fastpathTV.DecMapUint32IntfV(v, false, d)
16010         case *map[uint32]interface{}:
16011                 var v2 map[uint32]interface{}
16012                 v2, changed = fastpathTV.DecMapUint32IntfV(*v, true, d)
16013                 if changed {
16014                         *v = v2
16015                 }
16016         case map[uint32]string:
16017                 fastpathTV.DecMapUint32StringV(v, false, d)
16018         case *map[uint32]string:
16019                 var v2 map[uint32]string
16020                 v2, changed = fastpathTV.DecMapUint32StringV(*v, true, d)
16021                 if changed {
16022                         *v = v2
16023                 }
16024         case map[uint32]uint:
16025                 fastpathTV.DecMapUint32UintV(v, false, d)
16026         case *map[uint32]uint:
16027                 var v2 map[uint32]uint
16028                 v2, changed = fastpathTV.DecMapUint32UintV(*v, true, d)
16029                 if changed {
16030                         *v = v2
16031                 }
16032         case map[uint32]uint8:
16033                 fastpathTV.DecMapUint32Uint8V(v, false, d)
16034         case *map[uint32]uint8:
16035                 var v2 map[uint32]uint8
16036                 v2, changed = fastpathTV.DecMapUint32Uint8V(*v, true, d)
16037                 if changed {
16038                         *v = v2
16039                 }
16040         case map[uint32]uint16:
16041                 fastpathTV.DecMapUint32Uint16V(v, false, d)
16042         case *map[uint32]uint16:
16043                 var v2 map[uint32]uint16
16044                 v2, changed = fastpathTV.DecMapUint32Uint16V(*v, true, d)
16045                 if changed {
16046                         *v = v2
16047                 }
16048         case map[uint32]uint32:
16049                 fastpathTV.DecMapUint32Uint32V(v, false, d)
16050         case *map[uint32]uint32:
16051                 var v2 map[uint32]uint32
16052                 v2, changed = fastpathTV.DecMapUint32Uint32V(*v, true, d)
16053                 if changed {
16054                         *v = v2
16055                 }
16056         case map[uint32]uint64:
16057                 fastpathTV.DecMapUint32Uint64V(v, false, d)
16058         case *map[uint32]uint64:
16059                 var v2 map[uint32]uint64
16060                 v2, changed = fastpathTV.DecMapUint32Uint64V(*v, true, d)
16061                 if changed {
16062                         *v = v2
16063                 }
16064         case map[uint32]uintptr:
16065                 fastpathTV.DecMapUint32UintptrV(v, false, d)
16066         case *map[uint32]uintptr:
16067                 var v2 map[uint32]uintptr
16068                 v2, changed = fastpathTV.DecMapUint32UintptrV(*v, true, d)
16069                 if changed {
16070                         *v = v2
16071                 }
16072         case map[uint32]int:
16073                 fastpathTV.DecMapUint32IntV(v, false, d)
16074         case *map[uint32]int:
16075                 var v2 map[uint32]int
16076                 v2, changed = fastpathTV.DecMapUint32IntV(*v, true, d)
16077                 if changed {
16078                         *v = v2
16079                 }
16080         case map[uint32]int8:
16081                 fastpathTV.DecMapUint32Int8V(v, false, d)
16082         case *map[uint32]int8:
16083                 var v2 map[uint32]int8
16084                 v2, changed = fastpathTV.DecMapUint32Int8V(*v, true, d)
16085                 if changed {
16086                         *v = v2
16087                 }
16088         case map[uint32]int16:
16089                 fastpathTV.DecMapUint32Int16V(v, false, d)
16090         case *map[uint32]int16:
16091                 var v2 map[uint32]int16
16092                 v2, changed = fastpathTV.DecMapUint32Int16V(*v, true, d)
16093                 if changed {
16094                         *v = v2
16095                 }
16096         case map[uint32]int32:
16097                 fastpathTV.DecMapUint32Int32V(v, false, d)
16098         case *map[uint32]int32:
16099                 var v2 map[uint32]int32
16100                 v2, changed = fastpathTV.DecMapUint32Int32V(*v, true, d)
16101                 if changed {
16102                         *v = v2
16103                 }
16104         case map[uint32]int64:
16105                 fastpathTV.DecMapUint32Int64V(v, false, d)
16106         case *map[uint32]int64:
16107                 var v2 map[uint32]int64
16108                 v2, changed = fastpathTV.DecMapUint32Int64V(*v, true, d)
16109                 if changed {
16110                         *v = v2
16111                 }
16112         case map[uint32]float32:
16113                 fastpathTV.DecMapUint32Float32V(v, false, d)
16114         case *map[uint32]float32:
16115                 var v2 map[uint32]float32
16116                 v2, changed = fastpathTV.DecMapUint32Float32V(*v, true, d)
16117                 if changed {
16118                         *v = v2
16119                 }
16120         case map[uint32]float64:
16121                 fastpathTV.DecMapUint32Float64V(v, false, d)
16122         case *map[uint32]float64:
16123                 var v2 map[uint32]float64
16124                 v2, changed = fastpathTV.DecMapUint32Float64V(*v, true, d)
16125                 if changed {
16126                         *v = v2
16127                 }
16128         case map[uint32]bool:
16129                 fastpathTV.DecMapUint32BoolV(v, false, d)
16130         case *map[uint32]bool:
16131                 var v2 map[uint32]bool
16132                 v2, changed = fastpathTV.DecMapUint32BoolV(*v, true, d)
16133                 if changed {
16134                         *v = v2
16135                 }
16136         case map[uint64]interface{}:
16137                 fastpathTV.DecMapUint64IntfV(v, false, d)
16138         case *map[uint64]interface{}:
16139                 var v2 map[uint64]interface{}
16140                 v2, changed = fastpathTV.DecMapUint64IntfV(*v, true, d)
16141                 if changed {
16142                         *v = v2
16143                 }
16144         case map[uint64]string:
16145                 fastpathTV.DecMapUint64StringV(v, false, d)
16146         case *map[uint64]string:
16147                 var v2 map[uint64]string
16148                 v2, changed = fastpathTV.DecMapUint64StringV(*v, true, d)
16149                 if changed {
16150                         *v = v2
16151                 }
16152         case map[uint64]uint:
16153                 fastpathTV.DecMapUint64UintV(v, false, d)
16154         case *map[uint64]uint:
16155                 var v2 map[uint64]uint
16156                 v2, changed = fastpathTV.DecMapUint64UintV(*v, true, d)
16157                 if changed {
16158                         *v = v2
16159                 }
16160         case map[uint64]uint8:
16161                 fastpathTV.DecMapUint64Uint8V(v, false, d)
16162         case *map[uint64]uint8:
16163                 var v2 map[uint64]uint8
16164                 v2, changed = fastpathTV.DecMapUint64Uint8V(*v, true, d)
16165                 if changed {
16166                         *v = v2
16167                 }
16168         case map[uint64]uint16:
16169                 fastpathTV.DecMapUint64Uint16V(v, false, d)
16170         case *map[uint64]uint16:
16171                 var v2 map[uint64]uint16
16172                 v2, changed = fastpathTV.DecMapUint64Uint16V(*v, true, d)
16173                 if changed {
16174                         *v = v2
16175                 }
16176         case map[uint64]uint32:
16177                 fastpathTV.DecMapUint64Uint32V(v, false, d)
16178         case *map[uint64]uint32:
16179                 var v2 map[uint64]uint32
16180                 v2, changed = fastpathTV.DecMapUint64Uint32V(*v, true, d)
16181                 if changed {
16182                         *v = v2
16183                 }
16184         case map[uint64]uint64:
16185                 fastpathTV.DecMapUint64Uint64V(v, false, d)
16186         case *map[uint64]uint64:
16187                 var v2 map[uint64]uint64
16188                 v2, changed = fastpathTV.DecMapUint64Uint64V(*v, true, d)
16189                 if changed {
16190                         *v = v2
16191                 }
16192         case map[uint64]uintptr:
16193                 fastpathTV.DecMapUint64UintptrV(v, false, d)
16194         case *map[uint64]uintptr:
16195                 var v2 map[uint64]uintptr
16196                 v2, changed = fastpathTV.DecMapUint64UintptrV(*v, true, d)
16197                 if changed {
16198                         *v = v2
16199                 }
16200         case map[uint64]int:
16201                 fastpathTV.DecMapUint64IntV(v, false, d)
16202         case *map[uint64]int:
16203                 var v2 map[uint64]int
16204                 v2, changed = fastpathTV.DecMapUint64IntV(*v, true, d)
16205                 if changed {
16206                         *v = v2
16207                 }
16208         case map[uint64]int8:
16209                 fastpathTV.DecMapUint64Int8V(v, false, d)
16210         case *map[uint64]int8:
16211                 var v2 map[uint64]int8
16212                 v2, changed = fastpathTV.DecMapUint64Int8V(*v, true, d)
16213                 if changed {
16214                         *v = v2
16215                 }
16216         case map[uint64]int16:
16217                 fastpathTV.DecMapUint64Int16V(v, false, d)
16218         case *map[uint64]int16:
16219                 var v2 map[uint64]int16
16220                 v2, changed = fastpathTV.DecMapUint64Int16V(*v, true, d)
16221                 if changed {
16222                         *v = v2
16223                 }
16224         case map[uint64]int32:
16225                 fastpathTV.DecMapUint64Int32V(v, false, d)
16226         case *map[uint64]int32:
16227                 var v2 map[uint64]int32
16228                 v2, changed = fastpathTV.DecMapUint64Int32V(*v, true, d)
16229                 if changed {
16230                         *v = v2
16231                 }
16232         case map[uint64]int64:
16233                 fastpathTV.DecMapUint64Int64V(v, false, d)
16234         case *map[uint64]int64:
16235                 var v2 map[uint64]int64
16236                 v2, changed = fastpathTV.DecMapUint64Int64V(*v, true, d)
16237                 if changed {
16238                         *v = v2
16239                 }
16240         case map[uint64]float32:
16241                 fastpathTV.DecMapUint64Float32V(v, false, d)
16242         case *map[uint64]float32:
16243                 var v2 map[uint64]float32
16244                 v2, changed = fastpathTV.DecMapUint64Float32V(*v, true, d)
16245                 if changed {
16246                         *v = v2
16247                 }
16248         case map[uint64]float64:
16249                 fastpathTV.DecMapUint64Float64V(v, false, d)
16250         case *map[uint64]float64:
16251                 var v2 map[uint64]float64
16252                 v2, changed = fastpathTV.DecMapUint64Float64V(*v, true, d)
16253                 if changed {
16254                         *v = v2
16255                 }
16256         case map[uint64]bool:
16257                 fastpathTV.DecMapUint64BoolV(v, false, d)
16258         case *map[uint64]bool:
16259                 var v2 map[uint64]bool
16260                 v2, changed = fastpathTV.DecMapUint64BoolV(*v, true, d)
16261                 if changed {
16262                         *v = v2
16263                 }
16264         case map[uintptr]interface{}:
16265                 fastpathTV.DecMapUintptrIntfV(v, false, d)
16266         case *map[uintptr]interface{}:
16267                 var v2 map[uintptr]interface{}
16268                 v2, changed = fastpathTV.DecMapUintptrIntfV(*v, true, d)
16269                 if changed {
16270                         *v = v2
16271                 }
16272         case map[uintptr]string:
16273                 fastpathTV.DecMapUintptrStringV(v, false, d)
16274         case *map[uintptr]string:
16275                 var v2 map[uintptr]string
16276                 v2, changed = fastpathTV.DecMapUintptrStringV(*v, true, d)
16277                 if changed {
16278                         *v = v2
16279                 }
16280         case map[uintptr]uint:
16281                 fastpathTV.DecMapUintptrUintV(v, false, d)
16282         case *map[uintptr]uint:
16283                 var v2 map[uintptr]uint
16284                 v2, changed = fastpathTV.DecMapUintptrUintV(*v, true, d)
16285                 if changed {
16286                         *v = v2
16287                 }
16288         case map[uintptr]uint8:
16289                 fastpathTV.DecMapUintptrUint8V(v, false, d)
16290         case *map[uintptr]uint8:
16291                 var v2 map[uintptr]uint8
16292                 v2, changed = fastpathTV.DecMapUintptrUint8V(*v, true, d)
16293                 if changed {
16294                         *v = v2
16295                 }
16296         case map[uintptr]uint16:
16297                 fastpathTV.DecMapUintptrUint16V(v, false, d)
16298         case *map[uintptr]uint16:
16299                 var v2 map[uintptr]uint16
16300                 v2, changed = fastpathTV.DecMapUintptrUint16V(*v, true, d)
16301                 if changed {
16302                         *v = v2
16303                 }
16304         case map[uintptr]uint32:
16305                 fastpathTV.DecMapUintptrUint32V(v, false, d)
16306         case *map[uintptr]uint32:
16307                 var v2 map[uintptr]uint32
16308                 v2, changed = fastpathTV.DecMapUintptrUint32V(*v, true, d)
16309                 if changed {
16310                         *v = v2
16311                 }
16312         case map[uintptr]uint64:
16313                 fastpathTV.DecMapUintptrUint64V(v, false, d)
16314         case *map[uintptr]uint64:
16315                 var v2 map[uintptr]uint64
16316                 v2, changed = fastpathTV.DecMapUintptrUint64V(*v, true, d)
16317                 if changed {
16318                         *v = v2
16319                 }
16320         case map[uintptr]uintptr:
16321                 fastpathTV.DecMapUintptrUintptrV(v, false, d)
16322         case *map[uintptr]uintptr:
16323                 var v2 map[uintptr]uintptr
16324                 v2, changed = fastpathTV.DecMapUintptrUintptrV(*v, true, d)
16325                 if changed {
16326                         *v = v2
16327                 }
16328         case map[uintptr]int:
16329                 fastpathTV.DecMapUintptrIntV(v, false, d)
16330         case *map[uintptr]int:
16331                 var v2 map[uintptr]int
16332                 v2, changed = fastpathTV.DecMapUintptrIntV(*v, true, d)
16333                 if changed {
16334                         *v = v2
16335                 }
16336         case map[uintptr]int8:
16337                 fastpathTV.DecMapUintptrInt8V(v, false, d)
16338         case *map[uintptr]int8:
16339                 var v2 map[uintptr]int8
16340                 v2, changed = fastpathTV.DecMapUintptrInt8V(*v, true, d)
16341                 if changed {
16342                         *v = v2
16343                 }
16344         case map[uintptr]int16:
16345                 fastpathTV.DecMapUintptrInt16V(v, false, d)
16346         case *map[uintptr]int16:
16347                 var v2 map[uintptr]int16
16348                 v2, changed = fastpathTV.DecMapUintptrInt16V(*v, true, d)
16349                 if changed {
16350                         *v = v2
16351                 }
16352         case map[uintptr]int32:
16353                 fastpathTV.DecMapUintptrInt32V(v, false, d)
16354         case *map[uintptr]int32:
16355                 var v2 map[uintptr]int32
16356                 v2, changed = fastpathTV.DecMapUintptrInt32V(*v, true, d)
16357                 if changed {
16358                         *v = v2
16359                 }
16360         case map[uintptr]int64:
16361                 fastpathTV.DecMapUintptrInt64V(v, false, d)
16362         case *map[uintptr]int64:
16363                 var v2 map[uintptr]int64
16364                 v2, changed = fastpathTV.DecMapUintptrInt64V(*v, true, d)
16365                 if changed {
16366                         *v = v2
16367                 }
16368         case map[uintptr]float32:
16369                 fastpathTV.DecMapUintptrFloat32V(v, false, d)
16370         case *map[uintptr]float32:
16371                 var v2 map[uintptr]float32
16372                 v2, changed = fastpathTV.DecMapUintptrFloat32V(*v, true, d)
16373                 if changed {
16374                         *v = v2
16375                 }
16376         case map[uintptr]float64:
16377                 fastpathTV.DecMapUintptrFloat64V(v, false, d)
16378         case *map[uintptr]float64:
16379                 var v2 map[uintptr]float64
16380                 v2, changed = fastpathTV.DecMapUintptrFloat64V(*v, true, d)
16381                 if changed {
16382                         *v = v2
16383                 }
16384         case map[uintptr]bool:
16385                 fastpathTV.DecMapUintptrBoolV(v, false, d)
16386         case *map[uintptr]bool:
16387                 var v2 map[uintptr]bool
16388                 v2, changed = fastpathTV.DecMapUintptrBoolV(*v, true, d)
16389                 if changed {
16390                         *v = v2
16391                 }
16392         case map[int]interface{}:
16393                 fastpathTV.DecMapIntIntfV(v, false, d)
16394         case *map[int]interface{}:
16395                 var v2 map[int]interface{}
16396                 v2, changed = fastpathTV.DecMapIntIntfV(*v, true, d)
16397                 if changed {
16398                         *v = v2
16399                 }
16400         case map[int]string:
16401                 fastpathTV.DecMapIntStringV(v, false, d)
16402         case *map[int]string:
16403                 var v2 map[int]string
16404                 v2, changed = fastpathTV.DecMapIntStringV(*v, true, d)
16405                 if changed {
16406                         *v = v2
16407                 }
16408         case map[int]uint:
16409                 fastpathTV.DecMapIntUintV(v, false, d)
16410         case *map[int]uint:
16411                 var v2 map[int]uint
16412                 v2, changed = fastpathTV.DecMapIntUintV(*v, true, d)
16413                 if changed {
16414                         *v = v2
16415                 }
16416         case map[int]uint8:
16417                 fastpathTV.DecMapIntUint8V(v, false, d)
16418         case *map[int]uint8:
16419                 var v2 map[int]uint8
16420                 v2, changed = fastpathTV.DecMapIntUint8V(*v, true, d)
16421                 if changed {
16422                         *v = v2
16423                 }
16424         case map[int]uint16:
16425                 fastpathTV.DecMapIntUint16V(v, false, d)
16426         case *map[int]uint16:
16427                 var v2 map[int]uint16
16428                 v2, changed = fastpathTV.DecMapIntUint16V(*v, true, d)
16429                 if changed {
16430                         *v = v2
16431                 }
16432         case map[int]uint32:
16433                 fastpathTV.DecMapIntUint32V(v, false, d)
16434         case *map[int]uint32:
16435                 var v2 map[int]uint32
16436                 v2, changed = fastpathTV.DecMapIntUint32V(*v, true, d)
16437                 if changed {
16438                         *v = v2
16439                 }
16440         case map[int]uint64:
16441                 fastpathTV.DecMapIntUint64V(v, false, d)
16442         case *map[int]uint64:
16443                 var v2 map[int]uint64
16444                 v2, changed = fastpathTV.DecMapIntUint64V(*v, true, d)
16445                 if changed {
16446                         *v = v2
16447                 }
16448         case map[int]uintptr:
16449                 fastpathTV.DecMapIntUintptrV(v, false, d)
16450         case *map[int]uintptr:
16451                 var v2 map[int]uintptr
16452                 v2, changed = fastpathTV.DecMapIntUintptrV(*v, true, d)
16453                 if changed {
16454                         *v = v2
16455                 }
16456         case map[int]int:
16457                 fastpathTV.DecMapIntIntV(v, false, d)
16458         case *map[int]int:
16459                 var v2 map[int]int
16460                 v2, changed = fastpathTV.DecMapIntIntV(*v, true, d)
16461                 if changed {
16462                         *v = v2
16463                 }
16464         case map[int]int8:
16465                 fastpathTV.DecMapIntInt8V(v, false, d)
16466         case *map[int]int8:
16467                 var v2 map[int]int8
16468                 v2, changed = fastpathTV.DecMapIntInt8V(*v, true, d)
16469                 if changed {
16470                         *v = v2
16471                 }
16472         case map[int]int16:
16473                 fastpathTV.DecMapIntInt16V(v, false, d)
16474         case *map[int]int16:
16475                 var v2 map[int]int16
16476                 v2, changed = fastpathTV.DecMapIntInt16V(*v, true, d)
16477                 if changed {
16478                         *v = v2
16479                 }
16480         case map[int]int32:
16481                 fastpathTV.DecMapIntInt32V(v, false, d)
16482         case *map[int]int32:
16483                 var v2 map[int]int32
16484                 v2, changed = fastpathTV.DecMapIntInt32V(*v, true, d)
16485                 if changed {
16486                         *v = v2
16487                 }
16488         case map[int]int64:
16489                 fastpathTV.DecMapIntInt64V(v, false, d)
16490         case *map[int]int64:
16491                 var v2 map[int]int64
16492                 v2, changed = fastpathTV.DecMapIntInt64V(*v, true, d)
16493                 if changed {
16494                         *v = v2
16495                 }
16496         case map[int]float32:
16497                 fastpathTV.DecMapIntFloat32V(v, false, d)
16498         case *map[int]float32:
16499                 var v2 map[int]float32
16500                 v2, changed = fastpathTV.DecMapIntFloat32V(*v, true, d)
16501                 if changed {
16502                         *v = v2
16503                 }
16504         case map[int]float64:
16505                 fastpathTV.DecMapIntFloat64V(v, false, d)
16506         case *map[int]float64:
16507                 var v2 map[int]float64
16508                 v2, changed = fastpathTV.DecMapIntFloat64V(*v, true, d)
16509                 if changed {
16510                         *v = v2
16511                 }
16512         case map[int]bool:
16513                 fastpathTV.DecMapIntBoolV(v, false, d)
16514         case *map[int]bool:
16515                 var v2 map[int]bool
16516                 v2, changed = fastpathTV.DecMapIntBoolV(*v, true, d)
16517                 if changed {
16518                         *v = v2
16519                 }
16520         case map[int8]interface{}:
16521                 fastpathTV.DecMapInt8IntfV(v, false, d)
16522         case *map[int8]interface{}:
16523                 var v2 map[int8]interface{}
16524                 v2, changed = fastpathTV.DecMapInt8IntfV(*v, true, d)
16525                 if changed {
16526                         *v = v2
16527                 }
16528         case map[int8]string:
16529                 fastpathTV.DecMapInt8StringV(v, false, d)
16530         case *map[int8]string:
16531                 var v2 map[int8]string
16532                 v2, changed = fastpathTV.DecMapInt8StringV(*v, true, d)
16533                 if changed {
16534                         *v = v2
16535                 }
16536         case map[int8]uint:
16537                 fastpathTV.DecMapInt8UintV(v, false, d)
16538         case *map[int8]uint:
16539                 var v2 map[int8]uint
16540                 v2, changed = fastpathTV.DecMapInt8UintV(*v, true, d)
16541                 if changed {
16542                         *v = v2
16543                 }
16544         case map[int8]uint8:
16545                 fastpathTV.DecMapInt8Uint8V(v, false, d)
16546         case *map[int8]uint8:
16547                 var v2 map[int8]uint8
16548                 v2, changed = fastpathTV.DecMapInt8Uint8V(*v, true, d)
16549                 if changed {
16550                         *v = v2
16551                 }
16552         case map[int8]uint16:
16553                 fastpathTV.DecMapInt8Uint16V(v, false, d)
16554         case *map[int8]uint16:
16555                 var v2 map[int8]uint16
16556                 v2, changed = fastpathTV.DecMapInt8Uint16V(*v, true, d)
16557                 if changed {
16558                         *v = v2
16559                 }
16560         case map[int8]uint32:
16561                 fastpathTV.DecMapInt8Uint32V(v, false, d)
16562         case *map[int8]uint32:
16563                 var v2 map[int8]uint32
16564                 v2, changed = fastpathTV.DecMapInt8Uint32V(*v, true, d)
16565                 if changed {
16566                         *v = v2
16567                 }
16568         case map[int8]uint64:
16569                 fastpathTV.DecMapInt8Uint64V(v, false, d)
16570         case *map[int8]uint64:
16571                 var v2 map[int8]uint64
16572                 v2, changed = fastpathTV.DecMapInt8Uint64V(*v, true, d)
16573                 if changed {
16574                         *v = v2
16575                 }
16576         case map[int8]uintptr:
16577                 fastpathTV.DecMapInt8UintptrV(v, false, d)
16578         case *map[int8]uintptr:
16579                 var v2 map[int8]uintptr
16580                 v2, changed = fastpathTV.DecMapInt8UintptrV(*v, true, d)
16581                 if changed {
16582                         *v = v2
16583                 }
16584         case map[int8]int:
16585                 fastpathTV.DecMapInt8IntV(v, false, d)
16586         case *map[int8]int:
16587                 var v2 map[int8]int
16588                 v2, changed = fastpathTV.DecMapInt8IntV(*v, true, d)
16589                 if changed {
16590                         *v = v2
16591                 }
16592         case map[int8]int8:
16593                 fastpathTV.DecMapInt8Int8V(v, false, d)
16594         case *map[int8]int8:
16595                 var v2 map[int8]int8
16596                 v2, changed = fastpathTV.DecMapInt8Int8V(*v, true, d)
16597                 if changed {
16598                         *v = v2
16599                 }
16600         case map[int8]int16:
16601                 fastpathTV.DecMapInt8Int16V(v, false, d)
16602         case *map[int8]int16:
16603                 var v2 map[int8]int16
16604                 v2, changed = fastpathTV.DecMapInt8Int16V(*v, true, d)
16605                 if changed {
16606                         *v = v2
16607                 }
16608         case map[int8]int32:
16609                 fastpathTV.DecMapInt8Int32V(v, false, d)
16610         case *map[int8]int32:
16611                 var v2 map[int8]int32
16612                 v2, changed = fastpathTV.DecMapInt8Int32V(*v, true, d)
16613                 if changed {
16614                         *v = v2
16615                 }
16616         case map[int8]int64:
16617                 fastpathTV.DecMapInt8Int64V(v, false, d)
16618         case *map[int8]int64:
16619                 var v2 map[int8]int64
16620                 v2, changed = fastpathTV.DecMapInt8Int64V(*v, true, d)
16621                 if changed {
16622                         *v = v2
16623                 }
16624         case map[int8]float32:
16625                 fastpathTV.DecMapInt8Float32V(v, false, d)
16626         case *map[int8]float32:
16627                 var v2 map[int8]float32
16628                 v2, changed = fastpathTV.DecMapInt8Float32V(*v, true, d)
16629                 if changed {
16630                         *v = v2
16631                 }
16632         case map[int8]float64:
16633                 fastpathTV.DecMapInt8Float64V(v, false, d)
16634         case *map[int8]float64:
16635                 var v2 map[int8]float64
16636                 v2, changed = fastpathTV.DecMapInt8Float64V(*v, true, d)
16637                 if changed {
16638                         *v = v2
16639                 }
16640         case map[int8]bool:
16641                 fastpathTV.DecMapInt8BoolV(v, false, d)
16642         case *map[int8]bool:
16643                 var v2 map[int8]bool
16644                 v2, changed = fastpathTV.DecMapInt8BoolV(*v, true, d)
16645                 if changed {
16646                         *v = v2
16647                 }
16648         case map[int16]interface{}:
16649                 fastpathTV.DecMapInt16IntfV(v, false, d)
16650         case *map[int16]interface{}:
16651                 var v2 map[int16]interface{}
16652                 v2, changed = fastpathTV.DecMapInt16IntfV(*v, true, d)
16653                 if changed {
16654                         *v = v2
16655                 }
16656         case map[int16]string:
16657                 fastpathTV.DecMapInt16StringV(v, false, d)
16658         case *map[int16]string:
16659                 var v2 map[int16]string
16660                 v2, changed = fastpathTV.DecMapInt16StringV(*v, true, d)
16661                 if changed {
16662                         *v = v2
16663                 }
16664         case map[int16]uint:
16665                 fastpathTV.DecMapInt16UintV(v, false, d)
16666         case *map[int16]uint:
16667                 var v2 map[int16]uint
16668                 v2, changed = fastpathTV.DecMapInt16UintV(*v, true, d)
16669                 if changed {
16670                         *v = v2
16671                 }
16672         case map[int16]uint8:
16673                 fastpathTV.DecMapInt16Uint8V(v, false, d)
16674         case *map[int16]uint8:
16675                 var v2 map[int16]uint8
16676                 v2, changed = fastpathTV.DecMapInt16Uint8V(*v, true, d)
16677                 if changed {
16678                         *v = v2
16679                 }
16680         case map[int16]uint16:
16681                 fastpathTV.DecMapInt16Uint16V(v, false, d)
16682         case *map[int16]uint16:
16683                 var v2 map[int16]uint16
16684                 v2, changed = fastpathTV.DecMapInt16Uint16V(*v, true, d)
16685                 if changed {
16686                         *v = v2
16687                 }
16688         case map[int16]uint32:
16689                 fastpathTV.DecMapInt16Uint32V(v, false, d)
16690         case *map[int16]uint32:
16691                 var v2 map[int16]uint32
16692                 v2, changed = fastpathTV.DecMapInt16Uint32V(*v, true, d)
16693                 if changed {
16694                         *v = v2
16695                 }
16696         case map[int16]uint64:
16697                 fastpathTV.DecMapInt16Uint64V(v, false, d)
16698         case *map[int16]uint64:
16699                 var v2 map[int16]uint64
16700                 v2, changed = fastpathTV.DecMapInt16Uint64V(*v, true, d)
16701                 if changed {
16702                         *v = v2
16703                 }
16704         case map[int16]uintptr:
16705                 fastpathTV.DecMapInt16UintptrV(v, false, d)
16706         case *map[int16]uintptr:
16707                 var v2 map[int16]uintptr
16708                 v2, changed = fastpathTV.DecMapInt16UintptrV(*v, true, d)
16709                 if changed {
16710                         *v = v2
16711                 }
16712         case map[int16]int:
16713                 fastpathTV.DecMapInt16IntV(v, false, d)
16714         case *map[int16]int:
16715                 var v2 map[int16]int
16716                 v2, changed = fastpathTV.DecMapInt16IntV(*v, true, d)
16717                 if changed {
16718                         *v = v2
16719                 }
16720         case map[int16]int8:
16721                 fastpathTV.DecMapInt16Int8V(v, false, d)
16722         case *map[int16]int8:
16723                 var v2 map[int16]int8
16724                 v2, changed = fastpathTV.DecMapInt16Int8V(*v, true, d)
16725                 if changed {
16726                         *v = v2
16727                 }
16728         case map[int16]int16:
16729                 fastpathTV.DecMapInt16Int16V(v, false, d)
16730         case *map[int16]int16:
16731                 var v2 map[int16]int16
16732                 v2, changed = fastpathTV.DecMapInt16Int16V(*v, true, d)
16733                 if changed {
16734                         *v = v2
16735                 }
16736         case map[int16]int32:
16737                 fastpathTV.DecMapInt16Int32V(v, false, d)
16738         case *map[int16]int32:
16739                 var v2 map[int16]int32
16740                 v2, changed = fastpathTV.DecMapInt16Int32V(*v, true, d)
16741                 if changed {
16742                         *v = v2
16743                 }
16744         case map[int16]int64:
16745                 fastpathTV.DecMapInt16Int64V(v, false, d)
16746         case *map[int16]int64:
16747                 var v2 map[int16]int64
16748                 v2, changed = fastpathTV.DecMapInt16Int64V(*v, true, d)
16749                 if changed {
16750                         *v = v2
16751                 }
16752         case map[int16]float32:
16753                 fastpathTV.DecMapInt16Float32V(v, false, d)
16754         case *map[int16]float32:
16755                 var v2 map[int16]float32
16756                 v2, changed = fastpathTV.DecMapInt16Float32V(*v, true, d)
16757                 if changed {
16758                         *v = v2
16759                 }
16760         case map[int16]float64:
16761                 fastpathTV.DecMapInt16Float64V(v, false, d)
16762         case *map[int16]float64:
16763                 var v2 map[int16]float64
16764                 v2, changed = fastpathTV.DecMapInt16Float64V(*v, true, d)
16765                 if changed {
16766                         *v = v2
16767                 }
16768         case map[int16]bool:
16769                 fastpathTV.DecMapInt16BoolV(v, false, d)
16770         case *map[int16]bool:
16771                 var v2 map[int16]bool
16772                 v2, changed = fastpathTV.DecMapInt16BoolV(*v, true, d)
16773                 if changed {
16774                         *v = v2
16775                 }
16776         case map[int32]interface{}:
16777                 fastpathTV.DecMapInt32IntfV(v, false, d)
16778         case *map[int32]interface{}:
16779                 var v2 map[int32]interface{}
16780                 v2, changed = fastpathTV.DecMapInt32IntfV(*v, true, d)
16781                 if changed {
16782                         *v = v2
16783                 }
16784         case map[int32]string:
16785                 fastpathTV.DecMapInt32StringV(v, false, d)
16786         case *map[int32]string:
16787                 var v2 map[int32]string
16788                 v2, changed = fastpathTV.DecMapInt32StringV(*v, true, d)
16789                 if changed {
16790                         *v = v2
16791                 }
16792         case map[int32]uint:
16793                 fastpathTV.DecMapInt32UintV(v, false, d)
16794         case *map[int32]uint:
16795                 var v2 map[int32]uint
16796                 v2, changed = fastpathTV.DecMapInt32UintV(*v, true, d)
16797                 if changed {
16798                         *v = v2
16799                 }
16800         case map[int32]uint8:
16801                 fastpathTV.DecMapInt32Uint8V(v, false, d)
16802         case *map[int32]uint8:
16803                 var v2 map[int32]uint8
16804                 v2, changed = fastpathTV.DecMapInt32Uint8V(*v, true, d)
16805                 if changed {
16806                         *v = v2
16807                 }
16808         case map[int32]uint16:
16809                 fastpathTV.DecMapInt32Uint16V(v, false, d)
16810         case *map[int32]uint16:
16811                 var v2 map[int32]uint16
16812                 v2, changed = fastpathTV.DecMapInt32Uint16V(*v, true, d)
16813                 if changed {
16814                         *v = v2
16815                 }
16816         case map[int32]uint32:
16817                 fastpathTV.DecMapInt32Uint32V(v, false, d)
16818         case *map[int32]uint32:
16819                 var v2 map[int32]uint32
16820                 v2, changed = fastpathTV.DecMapInt32Uint32V(*v, true, d)
16821                 if changed {
16822                         *v = v2
16823                 }
16824         case map[int32]uint64:
16825                 fastpathTV.DecMapInt32Uint64V(v, false, d)
16826         case *map[int32]uint64:
16827                 var v2 map[int32]uint64
16828                 v2, changed = fastpathTV.DecMapInt32Uint64V(*v, true, d)
16829                 if changed {
16830                         *v = v2
16831                 }
16832         case map[int32]uintptr:
16833                 fastpathTV.DecMapInt32UintptrV(v, false, d)
16834         case *map[int32]uintptr:
16835                 var v2 map[int32]uintptr
16836                 v2, changed = fastpathTV.DecMapInt32UintptrV(*v, true, d)
16837                 if changed {
16838                         *v = v2
16839                 }
16840         case map[int32]int:
16841                 fastpathTV.DecMapInt32IntV(v, false, d)
16842         case *map[int32]int:
16843                 var v2 map[int32]int
16844                 v2, changed = fastpathTV.DecMapInt32IntV(*v, true, d)
16845                 if changed {
16846                         *v = v2
16847                 }
16848         case map[int32]int8:
16849                 fastpathTV.DecMapInt32Int8V(v, false, d)
16850         case *map[int32]int8:
16851                 var v2 map[int32]int8
16852                 v2, changed = fastpathTV.DecMapInt32Int8V(*v, true, d)
16853                 if changed {
16854                         *v = v2
16855                 }
16856         case map[int32]int16:
16857                 fastpathTV.DecMapInt32Int16V(v, false, d)
16858         case *map[int32]int16:
16859                 var v2 map[int32]int16
16860                 v2, changed = fastpathTV.DecMapInt32Int16V(*v, true, d)
16861                 if changed {
16862                         *v = v2
16863                 }
16864         case map[int32]int32:
16865                 fastpathTV.DecMapInt32Int32V(v, false, d)
16866         case *map[int32]int32:
16867                 var v2 map[int32]int32
16868                 v2, changed = fastpathTV.DecMapInt32Int32V(*v, true, d)
16869                 if changed {
16870                         *v = v2
16871                 }
16872         case map[int32]int64:
16873                 fastpathTV.DecMapInt32Int64V(v, false, d)
16874         case *map[int32]int64:
16875                 var v2 map[int32]int64
16876                 v2, changed = fastpathTV.DecMapInt32Int64V(*v, true, d)
16877                 if changed {
16878                         *v = v2
16879                 }
16880         case map[int32]float32:
16881                 fastpathTV.DecMapInt32Float32V(v, false, d)
16882         case *map[int32]float32:
16883                 var v2 map[int32]float32
16884                 v2, changed = fastpathTV.DecMapInt32Float32V(*v, true, d)
16885                 if changed {
16886                         *v = v2
16887                 }
16888         case map[int32]float64:
16889                 fastpathTV.DecMapInt32Float64V(v, false, d)
16890         case *map[int32]float64:
16891                 var v2 map[int32]float64
16892                 v2, changed = fastpathTV.DecMapInt32Float64V(*v, true, d)
16893                 if changed {
16894                         *v = v2
16895                 }
16896         case map[int32]bool:
16897                 fastpathTV.DecMapInt32BoolV(v, false, d)
16898         case *map[int32]bool:
16899                 var v2 map[int32]bool
16900                 v2, changed = fastpathTV.DecMapInt32BoolV(*v, true, d)
16901                 if changed {
16902                         *v = v2
16903                 }
16904         case map[int64]interface{}:
16905                 fastpathTV.DecMapInt64IntfV(v, false, d)
16906         case *map[int64]interface{}:
16907                 var v2 map[int64]interface{}
16908                 v2, changed = fastpathTV.DecMapInt64IntfV(*v, true, d)
16909                 if changed {
16910                         *v = v2
16911                 }
16912         case map[int64]string:
16913                 fastpathTV.DecMapInt64StringV(v, false, d)
16914         case *map[int64]string:
16915                 var v2 map[int64]string
16916                 v2, changed = fastpathTV.DecMapInt64StringV(*v, true, d)
16917                 if changed {
16918                         *v = v2
16919                 }
16920         case map[int64]uint:
16921                 fastpathTV.DecMapInt64UintV(v, false, d)
16922         case *map[int64]uint:
16923                 var v2 map[int64]uint
16924                 v2, changed = fastpathTV.DecMapInt64UintV(*v, true, d)
16925                 if changed {
16926                         *v = v2
16927                 }
16928         case map[int64]uint8:
16929                 fastpathTV.DecMapInt64Uint8V(v, false, d)
16930         case *map[int64]uint8:
16931                 var v2 map[int64]uint8
16932                 v2, changed = fastpathTV.DecMapInt64Uint8V(*v, true, d)
16933                 if changed {
16934                         *v = v2
16935                 }
16936         case map[int64]uint16:
16937                 fastpathTV.DecMapInt64Uint16V(v, false, d)
16938         case *map[int64]uint16:
16939                 var v2 map[int64]uint16
16940                 v2, changed = fastpathTV.DecMapInt64Uint16V(*v, true, d)
16941                 if changed {
16942                         *v = v2
16943                 }
16944         case map[int64]uint32:
16945                 fastpathTV.DecMapInt64Uint32V(v, false, d)
16946         case *map[int64]uint32:
16947                 var v2 map[int64]uint32
16948                 v2, changed = fastpathTV.DecMapInt64Uint32V(*v, true, d)
16949                 if changed {
16950                         *v = v2
16951                 }
16952         case map[int64]uint64:
16953                 fastpathTV.DecMapInt64Uint64V(v, false, d)
16954         case *map[int64]uint64:
16955                 var v2 map[int64]uint64
16956                 v2, changed = fastpathTV.DecMapInt64Uint64V(*v, true, d)
16957                 if changed {
16958                         *v = v2
16959                 }
16960         case map[int64]uintptr:
16961                 fastpathTV.DecMapInt64UintptrV(v, false, d)
16962         case *map[int64]uintptr:
16963                 var v2 map[int64]uintptr
16964                 v2, changed = fastpathTV.DecMapInt64UintptrV(*v, true, d)
16965                 if changed {
16966                         *v = v2
16967                 }
16968         case map[int64]int:
16969                 fastpathTV.DecMapInt64IntV(v, false, d)
16970         case *map[int64]int:
16971                 var v2 map[int64]int
16972                 v2, changed = fastpathTV.DecMapInt64IntV(*v, true, d)
16973                 if changed {
16974                         *v = v2
16975                 }
16976         case map[int64]int8:
16977                 fastpathTV.DecMapInt64Int8V(v, false, d)
16978         case *map[int64]int8:
16979                 var v2 map[int64]int8
16980                 v2, changed = fastpathTV.DecMapInt64Int8V(*v, true, d)
16981                 if changed {
16982                         *v = v2
16983                 }
16984         case map[int64]int16:
16985                 fastpathTV.DecMapInt64Int16V(v, false, d)
16986         case *map[int64]int16:
16987                 var v2 map[int64]int16
16988                 v2, changed = fastpathTV.DecMapInt64Int16V(*v, true, d)
16989                 if changed {
16990                         *v = v2
16991                 }
16992         case map[int64]int32:
16993                 fastpathTV.DecMapInt64Int32V(v, false, d)
16994         case *map[int64]int32:
16995                 var v2 map[int64]int32
16996                 v2, changed = fastpathTV.DecMapInt64Int32V(*v, true, d)
16997                 if changed {
16998                         *v = v2
16999                 }
17000         case map[int64]int64:
17001                 fastpathTV.DecMapInt64Int64V(v, false, d)
17002         case *map[int64]int64:
17003                 var v2 map[int64]int64
17004                 v2, changed = fastpathTV.DecMapInt64Int64V(*v, true, d)
17005                 if changed {
17006                         *v = v2
17007                 }
17008         case map[int64]float32:
17009                 fastpathTV.DecMapInt64Float32V(v, false, d)
17010         case *map[int64]float32:
17011                 var v2 map[int64]float32
17012                 v2, changed = fastpathTV.DecMapInt64Float32V(*v, true, d)
17013                 if changed {
17014                         *v = v2
17015                 }
17016         case map[int64]float64:
17017                 fastpathTV.DecMapInt64Float64V(v, false, d)
17018         case *map[int64]float64:
17019                 var v2 map[int64]float64
17020                 v2, changed = fastpathTV.DecMapInt64Float64V(*v, true, d)
17021                 if changed {
17022                         *v = v2
17023                 }
17024         case map[int64]bool:
17025                 fastpathTV.DecMapInt64BoolV(v, false, d)
17026         case *map[int64]bool:
17027                 var v2 map[int64]bool
17028                 v2, changed = fastpathTV.DecMapInt64BoolV(*v, true, d)
17029                 if changed {
17030                         *v = v2
17031                 }
17032         case map[bool]interface{}:
17033                 fastpathTV.DecMapBoolIntfV(v, false, d)
17034         case *map[bool]interface{}:
17035                 var v2 map[bool]interface{}
17036                 v2, changed = fastpathTV.DecMapBoolIntfV(*v, true, d)
17037                 if changed {
17038                         *v = v2
17039                 }
17040         case map[bool]string:
17041                 fastpathTV.DecMapBoolStringV(v, false, d)
17042         case *map[bool]string:
17043                 var v2 map[bool]string
17044                 v2, changed = fastpathTV.DecMapBoolStringV(*v, true, d)
17045                 if changed {
17046                         *v = v2
17047                 }
17048         case map[bool]uint:
17049                 fastpathTV.DecMapBoolUintV(v, false, d)
17050         case *map[bool]uint:
17051                 var v2 map[bool]uint
17052                 v2, changed = fastpathTV.DecMapBoolUintV(*v, true, d)
17053                 if changed {
17054                         *v = v2
17055                 }
17056         case map[bool]uint8:
17057                 fastpathTV.DecMapBoolUint8V(v, false, d)
17058         case *map[bool]uint8:
17059                 var v2 map[bool]uint8
17060                 v2, changed = fastpathTV.DecMapBoolUint8V(*v, true, d)
17061                 if changed {
17062                         *v = v2
17063                 }
17064         case map[bool]uint16:
17065                 fastpathTV.DecMapBoolUint16V(v, false, d)
17066         case *map[bool]uint16:
17067                 var v2 map[bool]uint16
17068                 v2, changed = fastpathTV.DecMapBoolUint16V(*v, true, d)
17069                 if changed {
17070                         *v = v2
17071                 }
17072         case map[bool]uint32:
17073                 fastpathTV.DecMapBoolUint32V(v, false, d)
17074         case *map[bool]uint32:
17075                 var v2 map[bool]uint32
17076                 v2, changed = fastpathTV.DecMapBoolUint32V(*v, true, d)
17077                 if changed {
17078                         *v = v2
17079                 }
17080         case map[bool]uint64:
17081                 fastpathTV.DecMapBoolUint64V(v, false, d)
17082         case *map[bool]uint64:
17083                 var v2 map[bool]uint64
17084                 v2, changed = fastpathTV.DecMapBoolUint64V(*v, true, d)
17085                 if changed {
17086                         *v = v2
17087                 }
17088         case map[bool]uintptr:
17089                 fastpathTV.DecMapBoolUintptrV(v, false, d)
17090         case *map[bool]uintptr:
17091                 var v2 map[bool]uintptr
17092                 v2, changed = fastpathTV.DecMapBoolUintptrV(*v, true, d)
17093                 if changed {
17094                         *v = v2
17095                 }
17096         case map[bool]int:
17097                 fastpathTV.DecMapBoolIntV(v, false, d)
17098         case *map[bool]int:
17099                 var v2 map[bool]int
17100                 v2, changed = fastpathTV.DecMapBoolIntV(*v, true, d)
17101                 if changed {
17102                         *v = v2
17103                 }
17104         case map[bool]int8:
17105                 fastpathTV.DecMapBoolInt8V(v, false, d)
17106         case *map[bool]int8:
17107                 var v2 map[bool]int8
17108                 v2, changed = fastpathTV.DecMapBoolInt8V(*v, true, d)
17109                 if changed {
17110                         *v = v2
17111                 }
17112         case map[bool]int16:
17113                 fastpathTV.DecMapBoolInt16V(v, false, d)
17114         case *map[bool]int16:
17115                 var v2 map[bool]int16
17116                 v2, changed = fastpathTV.DecMapBoolInt16V(*v, true, d)
17117                 if changed {
17118                         *v = v2
17119                 }
17120         case map[bool]int32:
17121                 fastpathTV.DecMapBoolInt32V(v, false, d)
17122         case *map[bool]int32:
17123                 var v2 map[bool]int32
17124                 v2, changed = fastpathTV.DecMapBoolInt32V(*v, true, d)
17125                 if changed {
17126                         *v = v2
17127                 }
17128         case map[bool]int64:
17129                 fastpathTV.DecMapBoolInt64V(v, false, d)
17130         case *map[bool]int64:
17131                 var v2 map[bool]int64
17132                 v2, changed = fastpathTV.DecMapBoolInt64V(*v, true, d)
17133                 if changed {
17134                         *v = v2
17135                 }
17136         case map[bool]float32:
17137                 fastpathTV.DecMapBoolFloat32V(v, false, d)
17138         case *map[bool]float32:
17139                 var v2 map[bool]float32
17140                 v2, changed = fastpathTV.DecMapBoolFloat32V(*v, true, d)
17141                 if changed {
17142                         *v = v2
17143                 }
17144         case map[bool]float64:
17145                 fastpathTV.DecMapBoolFloat64V(v, false, d)
17146         case *map[bool]float64:
17147                 var v2 map[bool]float64
17148                 v2, changed = fastpathTV.DecMapBoolFloat64V(*v, true, d)
17149                 if changed {
17150                         *v = v2
17151                 }
17152         case map[bool]bool:
17153                 fastpathTV.DecMapBoolBoolV(v, false, d)
17154         case *map[bool]bool:
17155                 var v2 map[bool]bool
17156                 v2, changed = fastpathTV.DecMapBoolBoolV(*v, true, d)
17157                 if changed {
17158                         *v = v2
17159                 }
17160         default:
17161                 _ = v // workaround https://github.com/golang/go/issues/12927 seen in go1.4
17162                 return false
17163         }
17164         return true
17165 }
17166
17167 func fastpathDecodeSetZeroTypeSwitch(iv interface{}) bool {
17168         switch v := iv.(type) {
17169
17170         case *[]interface{}:
17171                 *v = nil
17172         case *[]string:
17173                 *v = nil
17174         case *[]float32:
17175                 *v = nil
17176         case *[]float64:
17177                 *v = nil
17178         case *[]uint:
17179                 *v = nil
17180         case *[]uint8:
17181                 *v = nil
17182         case *[]uint16:
17183                 *v = nil
17184         case *[]uint32:
17185                 *v = nil
17186         case *[]uint64:
17187                 *v = nil
17188         case *[]uintptr:
17189                 *v = nil
17190         case *[]int:
17191                 *v = nil
17192         case *[]int8:
17193                 *v = nil
17194         case *[]int16:
17195                 *v = nil
17196         case *[]int32:
17197                 *v = nil
17198         case *[]int64:
17199                 *v = nil
17200         case *[]bool:
17201                 *v = nil
17202
17203         case *map[interface{}]interface{}:
17204                 *v = nil
17205         case *map[interface{}]string:
17206                 *v = nil
17207         case *map[interface{}]uint:
17208                 *v = nil
17209         case *map[interface{}]uint8:
17210                 *v = nil
17211         case *map[interface{}]uint16:
17212                 *v = nil
17213         case *map[interface{}]uint32:
17214                 *v = nil
17215         case *map[interface{}]uint64:
17216                 *v = nil
17217         case *map[interface{}]uintptr:
17218                 *v = nil
17219         case *map[interface{}]int:
17220                 *v = nil
17221         case *map[interface{}]int8:
17222                 *v = nil
17223         case *map[interface{}]int16:
17224                 *v = nil
17225         case *map[interface{}]int32:
17226                 *v = nil
17227         case *map[interface{}]int64:
17228                 *v = nil
17229         case *map[interface{}]float32:
17230                 *v = nil
17231         case *map[interface{}]float64:
17232                 *v = nil
17233         case *map[interface{}]bool:
17234                 *v = nil
17235         case *map[string]interface{}:
17236                 *v = nil
17237         case *map[string]string:
17238                 *v = nil
17239         case *map[string]uint:
17240                 *v = nil
17241         case *map[string]uint8:
17242                 *v = nil
17243         case *map[string]uint16:
17244                 *v = nil
17245         case *map[string]uint32:
17246                 *v = nil
17247         case *map[string]uint64:
17248                 *v = nil
17249         case *map[string]uintptr:
17250                 *v = nil
17251         case *map[string]int:
17252                 *v = nil
17253         case *map[string]int8:
17254                 *v = nil
17255         case *map[string]int16:
17256                 *v = nil
17257         case *map[string]int32:
17258                 *v = nil
17259         case *map[string]int64:
17260                 *v = nil
17261         case *map[string]float32:
17262                 *v = nil
17263         case *map[string]float64:
17264                 *v = nil
17265         case *map[string]bool:
17266                 *v = nil
17267         case *map[float32]interface{}:
17268                 *v = nil
17269         case *map[float32]string:
17270                 *v = nil
17271         case *map[float32]uint:
17272                 *v = nil
17273         case *map[float32]uint8:
17274                 *v = nil
17275         case *map[float32]uint16:
17276                 *v = nil
17277         case *map[float32]uint32:
17278                 *v = nil
17279         case *map[float32]uint64:
17280                 *v = nil
17281         case *map[float32]uintptr:
17282                 *v = nil
17283         case *map[float32]int:
17284                 *v = nil
17285         case *map[float32]int8:
17286                 *v = nil
17287         case *map[float32]int16:
17288                 *v = nil
17289         case *map[float32]int32:
17290                 *v = nil
17291         case *map[float32]int64:
17292                 *v = nil
17293         case *map[float32]float32:
17294                 *v = nil
17295         case *map[float32]float64:
17296                 *v = nil
17297         case *map[float32]bool:
17298                 *v = nil
17299         case *map[float64]interface{}:
17300                 *v = nil
17301         case *map[float64]string:
17302                 *v = nil
17303         case *map[float64]uint:
17304                 *v = nil
17305         case *map[float64]uint8:
17306                 *v = nil
17307         case *map[float64]uint16:
17308                 *v = nil
17309         case *map[float64]uint32:
17310                 *v = nil
17311         case *map[float64]uint64:
17312                 *v = nil
17313         case *map[float64]uintptr:
17314                 *v = nil
17315         case *map[float64]int:
17316                 *v = nil
17317         case *map[float64]int8:
17318                 *v = nil
17319         case *map[float64]int16:
17320                 *v = nil
17321         case *map[float64]int32:
17322                 *v = nil
17323         case *map[float64]int64:
17324                 *v = nil
17325         case *map[float64]float32:
17326                 *v = nil
17327         case *map[float64]float64:
17328                 *v = nil
17329         case *map[float64]bool:
17330                 *v = nil
17331         case *map[uint]interface{}:
17332                 *v = nil
17333         case *map[uint]string:
17334                 *v = nil
17335         case *map[uint]uint:
17336                 *v = nil
17337         case *map[uint]uint8:
17338                 *v = nil
17339         case *map[uint]uint16:
17340                 *v = nil
17341         case *map[uint]uint32:
17342                 *v = nil
17343         case *map[uint]uint64:
17344                 *v = nil
17345         case *map[uint]uintptr:
17346                 *v = nil
17347         case *map[uint]int:
17348                 *v = nil
17349         case *map[uint]int8:
17350                 *v = nil
17351         case *map[uint]int16:
17352                 *v = nil
17353         case *map[uint]int32:
17354                 *v = nil
17355         case *map[uint]int64:
17356                 *v = nil
17357         case *map[uint]float32:
17358                 *v = nil
17359         case *map[uint]float64:
17360                 *v = nil
17361         case *map[uint]bool:
17362                 *v = nil
17363         case *map[uint8]interface{}:
17364                 *v = nil
17365         case *map[uint8]string:
17366                 *v = nil
17367         case *map[uint8]uint:
17368                 *v = nil
17369         case *map[uint8]uint8:
17370                 *v = nil
17371         case *map[uint8]uint16:
17372                 *v = nil
17373         case *map[uint8]uint32:
17374                 *v = nil
17375         case *map[uint8]uint64:
17376                 *v = nil
17377         case *map[uint8]uintptr:
17378                 *v = nil
17379         case *map[uint8]int:
17380                 *v = nil
17381         case *map[uint8]int8:
17382                 *v = nil
17383         case *map[uint8]int16:
17384                 *v = nil
17385         case *map[uint8]int32:
17386                 *v = nil
17387         case *map[uint8]int64:
17388                 *v = nil
17389         case *map[uint8]float32:
17390                 *v = nil
17391         case *map[uint8]float64:
17392                 *v = nil
17393         case *map[uint8]bool:
17394                 *v = nil
17395         case *map[uint16]interface{}:
17396                 *v = nil
17397         case *map[uint16]string:
17398                 *v = nil
17399         case *map[uint16]uint:
17400                 *v = nil
17401         case *map[uint16]uint8:
17402                 *v = nil
17403         case *map[uint16]uint16:
17404                 *v = nil
17405         case *map[uint16]uint32:
17406                 *v = nil
17407         case *map[uint16]uint64:
17408                 *v = nil
17409         case *map[uint16]uintptr:
17410                 *v = nil
17411         case *map[uint16]int:
17412                 *v = nil
17413         case *map[uint16]int8:
17414                 *v = nil
17415         case *map[uint16]int16:
17416                 *v = nil
17417         case *map[uint16]int32:
17418                 *v = nil
17419         case *map[uint16]int64:
17420                 *v = nil
17421         case *map[uint16]float32:
17422                 *v = nil
17423         case *map[uint16]float64:
17424                 *v = nil
17425         case *map[uint16]bool:
17426                 *v = nil
17427         case *map[uint32]interface{}:
17428                 *v = nil
17429         case *map[uint32]string:
17430                 *v = nil
17431         case *map[uint32]uint:
17432                 *v = nil
17433         case *map[uint32]uint8:
17434                 *v = nil
17435         case *map[uint32]uint16:
17436                 *v = nil
17437         case *map[uint32]uint32:
17438                 *v = nil
17439         case *map[uint32]uint64:
17440                 *v = nil
17441         case *map[uint32]uintptr:
17442                 *v = nil
17443         case *map[uint32]int:
17444                 *v = nil
17445         case *map[uint32]int8:
17446                 *v = nil
17447         case *map[uint32]int16:
17448                 *v = nil
17449         case *map[uint32]int32:
17450                 *v = nil
17451         case *map[uint32]int64:
17452                 *v = nil
17453         case *map[uint32]float32:
17454                 *v = nil
17455         case *map[uint32]float64:
17456                 *v = nil
17457         case *map[uint32]bool:
17458                 *v = nil
17459         case *map[uint64]interface{}:
17460                 *v = nil
17461         case *map[uint64]string:
17462                 *v = nil
17463         case *map[uint64]uint:
17464                 *v = nil
17465         case *map[uint64]uint8:
17466                 *v = nil
17467         case *map[uint64]uint16:
17468                 *v = nil
17469         case *map[uint64]uint32:
17470                 *v = nil
17471         case *map[uint64]uint64:
17472                 *v = nil
17473         case *map[uint64]uintptr:
17474                 *v = nil
17475         case *map[uint64]int:
17476                 *v = nil
17477         case *map[uint64]int8:
17478                 *v = nil
17479         case *map[uint64]int16:
17480                 *v = nil
17481         case *map[uint64]int32:
17482                 *v = nil
17483         case *map[uint64]int64:
17484                 *v = nil
17485         case *map[uint64]float32:
17486                 *v = nil
17487         case *map[uint64]float64:
17488                 *v = nil
17489         case *map[uint64]bool:
17490                 *v = nil
17491         case *map[uintptr]interface{}:
17492                 *v = nil
17493         case *map[uintptr]string:
17494                 *v = nil
17495         case *map[uintptr]uint:
17496                 *v = nil
17497         case *map[uintptr]uint8:
17498                 *v = nil
17499         case *map[uintptr]uint16:
17500                 *v = nil
17501         case *map[uintptr]uint32:
17502                 *v = nil
17503         case *map[uintptr]uint64:
17504                 *v = nil
17505         case *map[uintptr]uintptr:
17506                 *v = nil
17507         case *map[uintptr]int:
17508                 *v = nil
17509         case *map[uintptr]int8:
17510                 *v = nil
17511         case *map[uintptr]int16:
17512                 *v = nil
17513         case *map[uintptr]int32:
17514                 *v = nil
17515         case *map[uintptr]int64:
17516                 *v = nil
17517         case *map[uintptr]float32:
17518                 *v = nil
17519         case *map[uintptr]float64:
17520                 *v = nil
17521         case *map[uintptr]bool:
17522                 *v = nil
17523         case *map[int]interface{}:
17524                 *v = nil
17525         case *map[int]string:
17526                 *v = nil
17527         case *map[int]uint:
17528                 *v = nil
17529         case *map[int]uint8:
17530                 *v = nil
17531         case *map[int]uint16:
17532                 *v = nil
17533         case *map[int]uint32:
17534                 *v = nil
17535         case *map[int]uint64:
17536                 *v = nil
17537         case *map[int]uintptr:
17538                 *v = nil
17539         case *map[int]int:
17540                 *v = nil
17541         case *map[int]int8:
17542                 *v = nil
17543         case *map[int]int16:
17544                 *v = nil
17545         case *map[int]int32:
17546                 *v = nil
17547         case *map[int]int64:
17548                 *v = nil
17549         case *map[int]float32:
17550                 *v = nil
17551         case *map[int]float64:
17552                 *v = nil
17553         case *map[int]bool:
17554                 *v = nil
17555         case *map[int8]interface{}:
17556                 *v = nil
17557         case *map[int8]string:
17558                 *v = nil
17559         case *map[int8]uint:
17560                 *v = nil
17561         case *map[int8]uint8:
17562                 *v = nil
17563         case *map[int8]uint16:
17564                 *v = nil
17565         case *map[int8]uint32:
17566                 *v = nil
17567         case *map[int8]uint64:
17568                 *v = nil
17569         case *map[int8]uintptr:
17570                 *v = nil
17571         case *map[int8]int:
17572                 *v = nil
17573         case *map[int8]int8:
17574                 *v = nil
17575         case *map[int8]int16:
17576                 *v = nil
17577         case *map[int8]int32:
17578                 *v = nil
17579         case *map[int8]int64:
17580                 *v = nil
17581         case *map[int8]float32:
17582                 *v = nil
17583         case *map[int8]float64:
17584                 *v = nil
17585         case *map[int8]bool:
17586                 *v = nil
17587         case *map[int16]interface{}:
17588                 *v = nil
17589         case *map[int16]string:
17590                 *v = nil
17591         case *map[int16]uint:
17592                 *v = nil
17593         case *map[int16]uint8:
17594                 *v = nil
17595         case *map[int16]uint16:
17596                 *v = nil
17597         case *map[int16]uint32:
17598                 *v = nil
17599         case *map[int16]uint64:
17600                 *v = nil
17601         case *map[int16]uintptr:
17602                 *v = nil
17603         case *map[int16]int:
17604                 *v = nil
17605         case *map[int16]int8:
17606                 *v = nil
17607         case *map[int16]int16:
17608                 *v = nil
17609         case *map[int16]int32:
17610                 *v = nil
17611         case *map[int16]int64:
17612                 *v = nil
17613         case *map[int16]float32:
17614                 *v = nil
17615         case *map[int16]float64:
17616                 *v = nil
17617         case *map[int16]bool:
17618                 *v = nil
17619         case *map[int32]interface{}:
17620                 *v = nil
17621         case *map[int32]string:
17622                 *v = nil
17623         case *map[int32]uint:
17624                 *v = nil
17625         case *map[int32]uint8:
17626                 *v = nil
17627         case *map[int32]uint16:
17628                 *v = nil
17629         case *map[int32]uint32:
17630                 *v = nil
17631         case *map[int32]uint64:
17632                 *v = nil
17633         case *map[int32]uintptr:
17634                 *v = nil
17635         case *map[int32]int:
17636                 *v = nil
17637         case *map[int32]int8:
17638                 *v = nil
17639         case *map[int32]int16:
17640                 *v = nil
17641         case *map[int32]int32:
17642                 *v = nil
17643         case *map[int32]int64:
17644                 *v = nil
17645         case *map[int32]float32:
17646                 *v = nil
17647         case *map[int32]float64:
17648                 *v = nil
17649         case *map[int32]bool:
17650                 *v = nil
17651         case *map[int64]interface{}:
17652                 *v = nil
17653         case *map[int64]string:
17654                 *v = nil
17655         case *map[int64]uint:
17656                 *v = nil
17657         case *map[int64]uint8:
17658                 *v = nil
17659         case *map[int64]uint16:
17660                 *v = nil
17661         case *map[int64]uint32:
17662                 *v = nil
17663         case *map[int64]uint64:
17664                 *v = nil
17665         case *map[int64]uintptr:
17666                 *v = nil
17667         case *map[int64]int:
17668                 *v = nil
17669         case *map[int64]int8:
17670                 *v = nil
17671         case *map[int64]int16:
17672                 *v = nil
17673         case *map[int64]int32:
17674                 *v = nil
17675         case *map[int64]int64:
17676                 *v = nil
17677         case *map[int64]float32:
17678                 *v = nil
17679         case *map[int64]float64:
17680                 *v = nil
17681         case *map[int64]bool:
17682                 *v = nil
17683         case *map[bool]interface{}:
17684                 *v = nil
17685         case *map[bool]string:
17686                 *v = nil
17687         case *map[bool]uint:
17688                 *v = nil
17689         case *map[bool]uint8:
17690                 *v = nil
17691         case *map[bool]uint16:
17692                 *v = nil
17693         case *map[bool]uint32:
17694                 *v = nil
17695         case *map[bool]uint64:
17696                 *v = nil
17697         case *map[bool]uintptr:
17698                 *v = nil
17699         case *map[bool]int:
17700                 *v = nil
17701         case *map[bool]int8:
17702                 *v = nil
17703         case *map[bool]int16:
17704                 *v = nil
17705         case *map[bool]int32:
17706                 *v = nil
17707         case *map[bool]int64:
17708                 *v = nil
17709         case *map[bool]float32:
17710                 *v = nil
17711         case *map[bool]float64:
17712                 *v = nil
17713         case *map[bool]bool:
17714                 *v = nil
17715         default:
17716                 _ = v // workaround https://github.com/golang/go/issues/12927 seen in go1.4
17717                 return false
17718         }
17719         return true
17720 }
17721
17722 // -- -- fast path functions
17723
17724 func (d *Decoder) fastpathDecSliceIntfR(f *codecFnInfo, rv reflect.Value) {
17725         if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
17726                 vp := rv2i(rv).(*[]interface{})
17727                 v, changed := fastpathTV.DecSliceIntfV(*vp, !array, d)
17728                 if changed {
17729                         *vp = v
17730                 }
17731         } else {
17732                 v := rv2i(rv).([]interface{})
17733                 v2, changed := fastpathTV.DecSliceIntfV(v, !array, d)
17734                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
17735                         copy(v, v2)
17736                 }
17737         }
17738 }
17739 func (f fastpathT) DecSliceIntfX(vp *[]interface{}, d *Decoder) {
17740         v, changed := f.DecSliceIntfV(*vp, true, d)
17741         if changed {
17742                 *vp = v
17743         }
17744 }
17745 func (_ fastpathT) DecSliceIntfV(v []interface{}, canChange bool, d *Decoder) (_ []interface{}, changed bool) {
17746         dd := d.d
17747         slh, containerLenS := d.decSliceHelperStart()
17748         if containerLenS == 0 {
17749                 if canChange {
17750                         if v == nil {
17751                                 v = []interface{}{}
17752                         } else if len(v) != 0 {
17753                                 v = v[:0]
17754                         }
17755                         changed = true
17756                 }
17757                 slh.End()
17758                 return v, changed
17759         }
17760         d.depthIncr()
17761         hasLen := containerLenS > 0
17762         var xlen int
17763         if hasLen && canChange {
17764                 if containerLenS > cap(v) {
17765                         xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
17766                         if xlen <= cap(v) {
17767                                 v = v[:xlen]
17768                         } else {
17769                                 v = make([]interface{}, xlen)
17770                         }
17771                         changed = true
17772                 } else if containerLenS != len(v) {
17773                         v = v[:containerLenS]
17774                         changed = true
17775                 }
17776         }
17777         j := 0
17778         for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
17779                 if j == 0 && len(v) == 0 && canChange {
17780                         if hasLen {
17781                                 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
17782                         } else {
17783                                 xlen = 8
17784                         }
17785                         v = make([]interface{}, xlen)
17786                         changed = true
17787                 }
17788                 // if indefinite, etc, then expand the slice if necessary
17789                 var decodeIntoBlank bool
17790                 if j >= len(v) {
17791                         if canChange {
17792                                 v = append(v, nil)
17793                                 changed = true
17794                         } else {
17795                                 d.arrayCannotExpand(len(v), j+1)
17796                                 decodeIntoBlank = true
17797                         }
17798                 }
17799                 slh.ElemContainerState(j)
17800                 if decodeIntoBlank {
17801                         d.swallow()
17802                 } else if dd.TryDecodeAsNil() {
17803                         v[j] = nil
17804                 } else {
17805                         d.decode(&v[j])
17806                 }
17807         }
17808         if canChange {
17809                 if j < len(v) {
17810                         v = v[:j]
17811                         changed = true
17812                 } else if j == 0 && v == nil {
17813                         v = make([]interface{}, 0)
17814                         changed = true
17815                 }
17816         }
17817         slh.End()
17818         d.depthDecr()
17819         return v, changed
17820 }
17821
17822 func (d *Decoder) fastpathDecSliceStringR(f *codecFnInfo, rv reflect.Value) {
17823         if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
17824                 vp := rv2i(rv).(*[]string)
17825                 v, changed := fastpathTV.DecSliceStringV(*vp, !array, d)
17826                 if changed {
17827                         *vp = v
17828                 }
17829         } else {
17830                 v := rv2i(rv).([]string)
17831                 v2, changed := fastpathTV.DecSliceStringV(v, !array, d)
17832                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
17833                         copy(v, v2)
17834                 }
17835         }
17836 }
17837 func (f fastpathT) DecSliceStringX(vp *[]string, d *Decoder) {
17838         v, changed := f.DecSliceStringV(*vp, true, d)
17839         if changed {
17840                 *vp = v
17841         }
17842 }
17843 func (_ fastpathT) DecSliceStringV(v []string, canChange bool, d *Decoder) (_ []string, changed bool) {
17844         dd := d.d
17845         slh, containerLenS := d.decSliceHelperStart()
17846         if containerLenS == 0 {
17847                 if canChange {
17848                         if v == nil {
17849                                 v = []string{}
17850                         } else if len(v) != 0 {
17851                                 v = v[:0]
17852                         }
17853                         changed = true
17854                 }
17855                 slh.End()
17856                 return v, changed
17857         }
17858         d.depthIncr()
17859         hasLen := containerLenS > 0
17860         var xlen int
17861         if hasLen && canChange {
17862                 if containerLenS > cap(v) {
17863                         xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
17864                         if xlen <= cap(v) {
17865                                 v = v[:xlen]
17866                         } else {
17867                                 v = make([]string, xlen)
17868                         }
17869                         changed = true
17870                 } else if containerLenS != len(v) {
17871                         v = v[:containerLenS]
17872                         changed = true
17873                 }
17874         }
17875         j := 0
17876         for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
17877                 if j == 0 && len(v) == 0 && canChange {
17878                         if hasLen {
17879                                 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
17880                         } else {
17881                                 xlen = 8
17882                         }
17883                         v = make([]string, xlen)
17884                         changed = true
17885                 }
17886                 // if indefinite, etc, then expand the slice if necessary
17887                 var decodeIntoBlank bool
17888                 if j >= len(v) {
17889                         if canChange {
17890                                 v = append(v, "")
17891                                 changed = true
17892                         } else {
17893                                 d.arrayCannotExpand(len(v), j+1)
17894                                 decodeIntoBlank = true
17895                         }
17896                 }
17897                 slh.ElemContainerState(j)
17898                 if decodeIntoBlank {
17899                         d.swallow()
17900                 } else if dd.TryDecodeAsNil() {
17901                         v[j] = ""
17902                 } else {
17903                         v[j] = dd.DecodeString()
17904                 }
17905         }
17906         if canChange {
17907                 if j < len(v) {
17908                         v = v[:j]
17909                         changed = true
17910                 } else if j == 0 && v == nil {
17911                         v = make([]string, 0)
17912                         changed = true
17913                 }
17914         }
17915         slh.End()
17916         d.depthDecr()
17917         return v, changed
17918 }
17919
17920 func (d *Decoder) fastpathDecSliceFloat32R(f *codecFnInfo, rv reflect.Value) {
17921         if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
17922                 vp := rv2i(rv).(*[]float32)
17923                 v, changed := fastpathTV.DecSliceFloat32V(*vp, !array, d)
17924                 if changed {
17925                         *vp = v
17926                 }
17927         } else {
17928                 v := rv2i(rv).([]float32)
17929                 v2, changed := fastpathTV.DecSliceFloat32V(v, !array, d)
17930                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
17931                         copy(v, v2)
17932                 }
17933         }
17934 }
17935 func (f fastpathT) DecSliceFloat32X(vp *[]float32, d *Decoder) {
17936         v, changed := f.DecSliceFloat32V(*vp, true, d)
17937         if changed {
17938                 *vp = v
17939         }
17940 }
17941 func (_ fastpathT) DecSliceFloat32V(v []float32, canChange bool, d *Decoder) (_ []float32, changed bool) {
17942         dd := d.d
17943         slh, containerLenS := d.decSliceHelperStart()
17944         if containerLenS == 0 {
17945                 if canChange {
17946                         if v == nil {
17947                                 v = []float32{}
17948                         } else if len(v) != 0 {
17949                                 v = v[:0]
17950                         }
17951                         changed = true
17952                 }
17953                 slh.End()
17954                 return v, changed
17955         }
17956         d.depthIncr()
17957         hasLen := containerLenS > 0
17958         var xlen int
17959         if hasLen && canChange {
17960                 if containerLenS > cap(v) {
17961                         xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
17962                         if xlen <= cap(v) {
17963                                 v = v[:xlen]
17964                         } else {
17965                                 v = make([]float32, xlen)
17966                         }
17967                         changed = true
17968                 } else if containerLenS != len(v) {
17969                         v = v[:containerLenS]
17970                         changed = true
17971                 }
17972         }
17973         j := 0
17974         for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
17975                 if j == 0 && len(v) == 0 && canChange {
17976                         if hasLen {
17977                                 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
17978                         } else {
17979                                 xlen = 8
17980                         }
17981                         v = make([]float32, xlen)
17982                         changed = true
17983                 }
17984                 // if indefinite, etc, then expand the slice if necessary
17985                 var decodeIntoBlank bool
17986                 if j >= len(v) {
17987                         if canChange {
17988                                 v = append(v, 0)
17989                                 changed = true
17990                         } else {
17991                                 d.arrayCannotExpand(len(v), j+1)
17992                                 decodeIntoBlank = true
17993                         }
17994                 }
17995                 slh.ElemContainerState(j)
17996                 if decodeIntoBlank {
17997                         d.swallow()
17998                 } else if dd.TryDecodeAsNil() {
17999                         v[j] = 0
18000                 } else {
18001                         v[j] = float32(chkOvf.Float32V(dd.DecodeFloat64()))
18002                 }
18003         }
18004         if canChange {
18005                 if j < len(v) {
18006                         v = v[:j]
18007                         changed = true
18008                 } else if j == 0 && v == nil {
18009                         v = make([]float32, 0)
18010                         changed = true
18011                 }
18012         }
18013         slh.End()
18014         d.depthDecr()
18015         return v, changed
18016 }
18017
18018 func (d *Decoder) fastpathDecSliceFloat64R(f *codecFnInfo, rv reflect.Value) {
18019         if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18020                 vp := rv2i(rv).(*[]float64)
18021                 v, changed := fastpathTV.DecSliceFloat64V(*vp, !array, d)
18022                 if changed {
18023                         *vp = v
18024                 }
18025         } else {
18026                 v := rv2i(rv).([]float64)
18027                 v2, changed := fastpathTV.DecSliceFloat64V(v, !array, d)
18028                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18029                         copy(v, v2)
18030                 }
18031         }
18032 }
18033 func (f fastpathT) DecSliceFloat64X(vp *[]float64, d *Decoder) {
18034         v, changed := f.DecSliceFloat64V(*vp, true, d)
18035         if changed {
18036                 *vp = v
18037         }
18038 }
18039 func (_ fastpathT) DecSliceFloat64V(v []float64, canChange bool, d *Decoder) (_ []float64, changed bool) {
18040         dd := d.d
18041         slh, containerLenS := d.decSliceHelperStart()
18042         if containerLenS == 0 {
18043                 if canChange {
18044                         if v == nil {
18045                                 v = []float64{}
18046                         } else if len(v) != 0 {
18047                                 v = v[:0]
18048                         }
18049                         changed = true
18050                 }
18051                 slh.End()
18052                 return v, changed
18053         }
18054         d.depthIncr()
18055         hasLen := containerLenS > 0
18056         var xlen int
18057         if hasLen && canChange {
18058                 if containerLenS > cap(v) {
18059                         xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18060                         if xlen <= cap(v) {
18061                                 v = v[:xlen]
18062                         } else {
18063                                 v = make([]float64, xlen)
18064                         }
18065                         changed = true
18066                 } else if containerLenS != len(v) {
18067                         v = v[:containerLenS]
18068                         changed = true
18069                 }
18070         }
18071         j := 0
18072         for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18073                 if j == 0 && len(v) == 0 && canChange {
18074                         if hasLen {
18075                                 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18076                         } else {
18077                                 xlen = 8
18078                         }
18079                         v = make([]float64, xlen)
18080                         changed = true
18081                 }
18082                 // if indefinite, etc, then expand the slice if necessary
18083                 var decodeIntoBlank bool
18084                 if j >= len(v) {
18085                         if canChange {
18086                                 v = append(v, 0)
18087                                 changed = true
18088                         } else {
18089                                 d.arrayCannotExpand(len(v), j+1)
18090                                 decodeIntoBlank = true
18091                         }
18092                 }
18093                 slh.ElemContainerState(j)
18094                 if decodeIntoBlank {
18095                         d.swallow()
18096                 } else if dd.TryDecodeAsNil() {
18097                         v[j] = 0
18098                 } else {
18099                         v[j] = dd.DecodeFloat64()
18100                 }
18101         }
18102         if canChange {
18103                 if j < len(v) {
18104                         v = v[:j]
18105                         changed = true
18106                 } else if j == 0 && v == nil {
18107                         v = make([]float64, 0)
18108                         changed = true
18109                 }
18110         }
18111         slh.End()
18112         d.depthDecr()
18113         return v, changed
18114 }
18115
18116 func (d *Decoder) fastpathDecSliceUintR(f *codecFnInfo, rv reflect.Value) {
18117         if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18118                 vp := rv2i(rv).(*[]uint)
18119                 v, changed := fastpathTV.DecSliceUintV(*vp, !array, d)
18120                 if changed {
18121                         *vp = v
18122                 }
18123         } else {
18124                 v := rv2i(rv).([]uint)
18125                 v2, changed := fastpathTV.DecSliceUintV(v, !array, d)
18126                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18127                         copy(v, v2)
18128                 }
18129         }
18130 }
18131 func (f fastpathT) DecSliceUintX(vp *[]uint, d *Decoder) {
18132         v, changed := f.DecSliceUintV(*vp, true, d)
18133         if changed {
18134                 *vp = v
18135         }
18136 }
18137 func (_ fastpathT) DecSliceUintV(v []uint, canChange bool, d *Decoder) (_ []uint, changed bool) {
18138         dd := d.d
18139         slh, containerLenS := d.decSliceHelperStart()
18140         if containerLenS == 0 {
18141                 if canChange {
18142                         if v == nil {
18143                                 v = []uint{}
18144                         } else if len(v) != 0 {
18145                                 v = v[:0]
18146                         }
18147                         changed = true
18148                 }
18149                 slh.End()
18150                 return v, changed
18151         }
18152         d.depthIncr()
18153         hasLen := containerLenS > 0
18154         var xlen int
18155         if hasLen && canChange {
18156                 if containerLenS > cap(v) {
18157                         xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18158                         if xlen <= cap(v) {
18159                                 v = v[:xlen]
18160                         } else {
18161                                 v = make([]uint, xlen)
18162                         }
18163                         changed = true
18164                 } else if containerLenS != len(v) {
18165                         v = v[:containerLenS]
18166                         changed = true
18167                 }
18168         }
18169         j := 0
18170         for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18171                 if j == 0 && len(v) == 0 && canChange {
18172                         if hasLen {
18173                                 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18174                         } else {
18175                                 xlen = 8
18176                         }
18177                         v = make([]uint, xlen)
18178                         changed = true
18179                 }
18180                 // if indefinite, etc, then expand the slice if necessary
18181                 var decodeIntoBlank bool
18182                 if j >= len(v) {
18183                         if canChange {
18184                                 v = append(v, 0)
18185                                 changed = true
18186                         } else {
18187                                 d.arrayCannotExpand(len(v), j+1)
18188                                 decodeIntoBlank = true
18189                         }
18190                 }
18191                 slh.ElemContainerState(j)
18192                 if decodeIntoBlank {
18193                         d.swallow()
18194                 } else if dd.TryDecodeAsNil() {
18195                         v[j] = 0
18196                 } else {
18197                         v[j] = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
18198                 }
18199         }
18200         if canChange {
18201                 if j < len(v) {
18202                         v = v[:j]
18203                         changed = true
18204                 } else if j == 0 && v == nil {
18205                         v = make([]uint, 0)
18206                         changed = true
18207                 }
18208         }
18209         slh.End()
18210         d.depthDecr()
18211         return v, changed
18212 }
18213
18214 func (d *Decoder) fastpathDecSliceUint8R(f *codecFnInfo, rv reflect.Value) {
18215         if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18216                 vp := rv2i(rv).(*[]uint8)
18217                 v, changed := fastpathTV.DecSliceUint8V(*vp, !array, d)
18218                 if changed {
18219                         *vp = v
18220                 }
18221         } else {
18222                 v := rv2i(rv).([]uint8)
18223                 v2, changed := fastpathTV.DecSliceUint8V(v, !array, d)
18224                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18225                         copy(v, v2)
18226                 }
18227         }
18228 }
18229 func (f fastpathT) DecSliceUint8X(vp *[]uint8, d *Decoder) {
18230         v, changed := f.DecSliceUint8V(*vp, true, d)
18231         if changed {
18232                 *vp = v
18233         }
18234 }
18235 func (_ fastpathT) DecSliceUint8V(v []uint8, canChange bool, d *Decoder) (_ []uint8, changed bool) {
18236         dd := d.d
18237         slh, containerLenS := d.decSliceHelperStart()
18238         if containerLenS == 0 {
18239                 if canChange {
18240                         if v == nil {
18241                                 v = []uint8{}
18242                         } else if len(v) != 0 {
18243                                 v = v[:0]
18244                         }
18245                         changed = true
18246                 }
18247                 slh.End()
18248                 return v, changed
18249         }
18250         d.depthIncr()
18251         hasLen := containerLenS > 0
18252         var xlen int
18253         if hasLen && canChange {
18254                 if containerLenS > cap(v) {
18255                         xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
18256                         if xlen <= cap(v) {
18257                                 v = v[:xlen]
18258                         } else {
18259                                 v = make([]uint8, xlen)
18260                         }
18261                         changed = true
18262                 } else if containerLenS != len(v) {
18263                         v = v[:containerLenS]
18264                         changed = true
18265                 }
18266         }
18267         j := 0
18268         for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18269                 if j == 0 && len(v) == 0 && canChange {
18270                         if hasLen {
18271                                 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
18272                         } else {
18273                                 xlen = 8
18274                         }
18275                         v = make([]uint8, xlen)
18276                         changed = true
18277                 }
18278                 // if indefinite, etc, then expand the slice if necessary
18279                 var decodeIntoBlank bool
18280                 if j >= len(v) {
18281                         if canChange {
18282                                 v = append(v, 0)
18283                                 changed = true
18284                         } else {
18285                                 d.arrayCannotExpand(len(v), j+1)
18286                                 decodeIntoBlank = true
18287                         }
18288                 }
18289                 slh.ElemContainerState(j)
18290                 if decodeIntoBlank {
18291                         d.swallow()
18292                 } else if dd.TryDecodeAsNil() {
18293                         v[j] = 0
18294                 } else {
18295                         v[j] = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
18296                 }
18297         }
18298         if canChange {
18299                 if j < len(v) {
18300                         v = v[:j]
18301                         changed = true
18302                 } else if j == 0 && v == nil {
18303                         v = make([]uint8, 0)
18304                         changed = true
18305                 }
18306         }
18307         slh.End()
18308         d.depthDecr()
18309         return v, changed
18310 }
18311
18312 func (d *Decoder) fastpathDecSliceUint16R(f *codecFnInfo, rv reflect.Value) {
18313         if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18314                 vp := rv2i(rv).(*[]uint16)
18315                 v, changed := fastpathTV.DecSliceUint16V(*vp, !array, d)
18316                 if changed {
18317                         *vp = v
18318                 }
18319         } else {
18320                 v := rv2i(rv).([]uint16)
18321                 v2, changed := fastpathTV.DecSliceUint16V(v, !array, d)
18322                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18323                         copy(v, v2)
18324                 }
18325         }
18326 }
18327 func (f fastpathT) DecSliceUint16X(vp *[]uint16, d *Decoder) {
18328         v, changed := f.DecSliceUint16V(*vp, true, d)
18329         if changed {
18330                 *vp = v
18331         }
18332 }
18333 func (_ fastpathT) DecSliceUint16V(v []uint16, canChange bool, d *Decoder) (_ []uint16, changed bool) {
18334         dd := d.d
18335         slh, containerLenS := d.decSliceHelperStart()
18336         if containerLenS == 0 {
18337                 if canChange {
18338                         if v == nil {
18339                                 v = []uint16{}
18340                         } else if len(v) != 0 {
18341                                 v = v[:0]
18342                         }
18343                         changed = true
18344                 }
18345                 slh.End()
18346                 return v, changed
18347         }
18348         d.depthIncr()
18349         hasLen := containerLenS > 0
18350         var xlen int
18351         if hasLen && canChange {
18352                 if containerLenS > cap(v) {
18353                         xlen = decInferLen(containerLenS, d.h.MaxInitLen, 2)
18354                         if xlen <= cap(v) {
18355                                 v = v[:xlen]
18356                         } else {
18357                                 v = make([]uint16, xlen)
18358                         }
18359                         changed = true
18360                 } else if containerLenS != len(v) {
18361                         v = v[:containerLenS]
18362                         changed = true
18363                 }
18364         }
18365         j := 0
18366         for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18367                 if j == 0 && len(v) == 0 && canChange {
18368                         if hasLen {
18369                                 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 2)
18370                         } else {
18371                                 xlen = 8
18372                         }
18373                         v = make([]uint16, xlen)
18374                         changed = true
18375                 }
18376                 // if indefinite, etc, then expand the slice if necessary
18377                 var decodeIntoBlank bool
18378                 if j >= len(v) {
18379                         if canChange {
18380                                 v = append(v, 0)
18381                                 changed = true
18382                         } else {
18383                                 d.arrayCannotExpand(len(v), j+1)
18384                                 decodeIntoBlank = true
18385                         }
18386                 }
18387                 slh.ElemContainerState(j)
18388                 if decodeIntoBlank {
18389                         d.swallow()
18390                 } else if dd.TryDecodeAsNil() {
18391                         v[j] = 0
18392                 } else {
18393                         v[j] = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
18394                 }
18395         }
18396         if canChange {
18397                 if j < len(v) {
18398                         v = v[:j]
18399                         changed = true
18400                 } else if j == 0 && v == nil {
18401                         v = make([]uint16, 0)
18402                         changed = true
18403                 }
18404         }
18405         slh.End()
18406         d.depthDecr()
18407         return v, changed
18408 }
18409
18410 func (d *Decoder) fastpathDecSliceUint32R(f *codecFnInfo, rv reflect.Value) {
18411         if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18412                 vp := rv2i(rv).(*[]uint32)
18413                 v, changed := fastpathTV.DecSliceUint32V(*vp, !array, d)
18414                 if changed {
18415                         *vp = v
18416                 }
18417         } else {
18418                 v := rv2i(rv).([]uint32)
18419                 v2, changed := fastpathTV.DecSliceUint32V(v, !array, d)
18420                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18421                         copy(v, v2)
18422                 }
18423         }
18424 }
18425 func (f fastpathT) DecSliceUint32X(vp *[]uint32, d *Decoder) {
18426         v, changed := f.DecSliceUint32V(*vp, true, d)
18427         if changed {
18428                 *vp = v
18429         }
18430 }
18431 func (_ fastpathT) DecSliceUint32V(v []uint32, canChange bool, d *Decoder) (_ []uint32, changed bool) {
18432         dd := d.d
18433         slh, containerLenS := d.decSliceHelperStart()
18434         if containerLenS == 0 {
18435                 if canChange {
18436                         if v == nil {
18437                                 v = []uint32{}
18438                         } else if len(v) != 0 {
18439                                 v = v[:0]
18440                         }
18441                         changed = true
18442                 }
18443                 slh.End()
18444                 return v, changed
18445         }
18446         d.depthIncr()
18447         hasLen := containerLenS > 0
18448         var xlen int
18449         if hasLen && canChange {
18450                 if containerLenS > cap(v) {
18451                         xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
18452                         if xlen <= cap(v) {
18453                                 v = v[:xlen]
18454                         } else {
18455                                 v = make([]uint32, xlen)
18456                         }
18457                         changed = true
18458                 } else if containerLenS != len(v) {
18459                         v = v[:containerLenS]
18460                         changed = true
18461                 }
18462         }
18463         j := 0
18464         for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18465                 if j == 0 && len(v) == 0 && canChange {
18466                         if hasLen {
18467                                 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
18468                         } else {
18469                                 xlen = 8
18470                         }
18471                         v = make([]uint32, xlen)
18472                         changed = true
18473                 }
18474                 // if indefinite, etc, then expand the slice if necessary
18475                 var decodeIntoBlank bool
18476                 if j >= len(v) {
18477                         if canChange {
18478                                 v = append(v, 0)
18479                                 changed = true
18480                         } else {
18481                                 d.arrayCannotExpand(len(v), j+1)
18482                                 decodeIntoBlank = true
18483                         }
18484                 }
18485                 slh.ElemContainerState(j)
18486                 if decodeIntoBlank {
18487                         d.swallow()
18488                 } else if dd.TryDecodeAsNil() {
18489                         v[j] = 0
18490                 } else {
18491                         v[j] = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
18492                 }
18493         }
18494         if canChange {
18495                 if j < len(v) {
18496                         v = v[:j]
18497                         changed = true
18498                 } else if j == 0 && v == nil {
18499                         v = make([]uint32, 0)
18500                         changed = true
18501                 }
18502         }
18503         slh.End()
18504         d.depthDecr()
18505         return v, changed
18506 }
18507
18508 func (d *Decoder) fastpathDecSliceUint64R(f *codecFnInfo, rv reflect.Value) {
18509         if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18510                 vp := rv2i(rv).(*[]uint64)
18511                 v, changed := fastpathTV.DecSliceUint64V(*vp, !array, d)
18512                 if changed {
18513                         *vp = v
18514                 }
18515         } else {
18516                 v := rv2i(rv).([]uint64)
18517                 v2, changed := fastpathTV.DecSliceUint64V(v, !array, d)
18518                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18519                         copy(v, v2)
18520                 }
18521         }
18522 }
18523 func (f fastpathT) DecSliceUint64X(vp *[]uint64, d *Decoder) {
18524         v, changed := f.DecSliceUint64V(*vp, true, d)
18525         if changed {
18526                 *vp = v
18527         }
18528 }
18529 func (_ fastpathT) DecSliceUint64V(v []uint64, canChange bool, d *Decoder) (_ []uint64, changed bool) {
18530         dd := d.d
18531         slh, containerLenS := d.decSliceHelperStart()
18532         if containerLenS == 0 {
18533                 if canChange {
18534                         if v == nil {
18535                                 v = []uint64{}
18536                         } else if len(v) != 0 {
18537                                 v = v[:0]
18538                         }
18539                         changed = true
18540                 }
18541                 slh.End()
18542                 return v, changed
18543         }
18544         d.depthIncr()
18545         hasLen := containerLenS > 0
18546         var xlen int
18547         if hasLen && canChange {
18548                 if containerLenS > cap(v) {
18549                         xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18550                         if xlen <= cap(v) {
18551                                 v = v[:xlen]
18552                         } else {
18553                                 v = make([]uint64, xlen)
18554                         }
18555                         changed = true
18556                 } else if containerLenS != len(v) {
18557                         v = v[:containerLenS]
18558                         changed = true
18559                 }
18560         }
18561         j := 0
18562         for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18563                 if j == 0 && len(v) == 0 && canChange {
18564                         if hasLen {
18565                                 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18566                         } else {
18567                                 xlen = 8
18568                         }
18569                         v = make([]uint64, xlen)
18570                         changed = true
18571                 }
18572                 // if indefinite, etc, then expand the slice if necessary
18573                 var decodeIntoBlank bool
18574                 if j >= len(v) {
18575                         if canChange {
18576                                 v = append(v, 0)
18577                                 changed = true
18578                         } else {
18579                                 d.arrayCannotExpand(len(v), j+1)
18580                                 decodeIntoBlank = true
18581                         }
18582                 }
18583                 slh.ElemContainerState(j)
18584                 if decodeIntoBlank {
18585                         d.swallow()
18586                 } else if dd.TryDecodeAsNil() {
18587                         v[j] = 0
18588                 } else {
18589                         v[j] = dd.DecodeUint64()
18590                 }
18591         }
18592         if canChange {
18593                 if j < len(v) {
18594                         v = v[:j]
18595                         changed = true
18596                 } else if j == 0 && v == nil {
18597                         v = make([]uint64, 0)
18598                         changed = true
18599                 }
18600         }
18601         slh.End()
18602         d.depthDecr()
18603         return v, changed
18604 }
18605
18606 func (d *Decoder) fastpathDecSliceUintptrR(f *codecFnInfo, rv reflect.Value) {
18607         if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18608                 vp := rv2i(rv).(*[]uintptr)
18609                 v, changed := fastpathTV.DecSliceUintptrV(*vp, !array, d)
18610                 if changed {
18611                         *vp = v
18612                 }
18613         } else {
18614                 v := rv2i(rv).([]uintptr)
18615                 v2, changed := fastpathTV.DecSliceUintptrV(v, !array, d)
18616                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18617                         copy(v, v2)
18618                 }
18619         }
18620 }
18621 func (f fastpathT) DecSliceUintptrX(vp *[]uintptr, d *Decoder) {
18622         v, changed := f.DecSliceUintptrV(*vp, true, d)
18623         if changed {
18624                 *vp = v
18625         }
18626 }
18627 func (_ fastpathT) DecSliceUintptrV(v []uintptr, canChange bool, d *Decoder) (_ []uintptr, changed bool) {
18628         dd := d.d
18629         slh, containerLenS := d.decSliceHelperStart()
18630         if containerLenS == 0 {
18631                 if canChange {
18632                         if v == nil {
18633                                 v = []uintptr{}
18634                         } else if len(v) != 0 {
18635                                 v = v[:0]
18636                         }
18637                         changed = true
18638                 }
18639                 slh.End()
18640                 return v, changed
18641         }
18642         d.depthIncr()
18643         hasLen := containerLenS > 0
18644         var xlen int
18645         if hasLen && canChange {
18646                 if containerLenS > cap(v) {
18647                         xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18648                         if xlen <= cap(v) {
18649                                 v = v[:xlen]
18650                         } else {
18651                                 v = make([]uintptr, xlen)
18652                         }
18653                         changed = true
18654                 } else if containerLenS != len(v) {
18655                         v = v[:containerLenS]
18656                         changed = true
18657                 }
18658         }
18659         j := 0
18660         for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18661                 if j == 0 && len(v) == 0 && canChange {
18662                         if hasLen {
18663                                 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18664                         } else {
18665                                 xlen = 8
18666                         }
18667                         v = make([]uintptr, xlen)
18668                         changed = true
18669                 }
18670                 // if indefinite, etc, then expand the slice if necessary
18671                 var decodeIntoBlank bool
18672                 if j >= len(v) {
18673                         if canChange {
18674                                 v = append(v, 0)
18675                                 changed = true
18676                         } else {
18677                                 d.arrayCannotExpand(len(v), j+1)
18678                                 decodeIntoBlank = true
18679                         }
18680                 }
18681                 slh.ElemContainerState(j)
18682                 if decodeIntoBlank {
18683                         d.swallow()
18684                 } else if dd.TryDecodeAsNil() {
18685                         v[j] = 0
18686                 } else {
18687                         v[j] = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
18688                 }
18689         }
18690         if canChange {
18691                 if j < len(v) {
18692                         v = v[:j]
18693                         changed = true
18694                 } else if j == 0 && v == nil {
18695                         v = make([]uintptr, 0)
18696                         changed = true
18697                 }
18698         }
18699         slh.End()
18700         d.depthDecr()
18701         return v, changed
18702 }
18703
18704 func (d *Decoder) fastpathDecSliceIntR(f *codecFnInfo, rv reflect.Value) {
18705         if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18706                 vp := rv2i(rv).(*[]int)
18707                 v, changed := fastpathTV.DecSliceIntV(*vp, !array, d)
18708                 if changed {
18709                         *vp = v
18710                 }
18711         } else {
18712                 v := rv2i(rv).([]int)
18713                 v2, changed := fastpathTV.DecSliceIntV(v, !array, d)
18714                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18715                         copy(v, v2)
18716                 }
18717         }
18718 }
18719 func (f fastpathT) DecSliceIntX(vp *[]int, d *Decoder) {
18720         v, changed := f.DecSliceIntV(*vp, true, d)
18721         if changed {
18722                 *vp = v
18723         }
18724 }
18725 func (_ fastpathT) DecSliceIntV(v []int, canChange bool, d *Decoder) (_ []int, changed bool) {
18726         dd := d.d
18727         slh, containerLenS := d.decSliceHelperStart()
18728         if containerLenS == 0 {
18729                 if canChange {
18730                         if v == nil {
18731                                 v = []int{}
18732                         } else if len(v) != 0 {
18733                                 v = v[:0]
18734                         }
18735                         changed = true
18736                 }
18737                 slh.End()
18738                 return v, changed
18739         }
18740         d.depthIncr()
18741         hasLen := containerLenS > 0
18742         var xlen int
18743         if hasLen && canChange {
18744                 if containerLenS > cap(v) {
18745                         xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18746                         if xlen <= cap(v) {
18747                                 v = v[:xlen]
18748                         } else {
18749                                 v = make([]int, xlen)
18750                         }
18751                         changed = true
18752                 } else if containerLenS != len(v) {
18753                         v = v[:containerLenS]
18754                         changed = true
18755                 }
18756         }
18757         j := 0
18758         for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18759                 if j == 0 && len(v) == 0 && canChange {
18760                         if hasLen {
18761                                 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18762                         } else {
18763                                 xlen = 8
18764                         }
18765                         v = make([]int, xlen)
18766                         changed = true
18767                 }
18768                 // if indefinite, etc, then expand the slice if necessary
18769                 var decodeIntoBlank bool
18770                 if j >= len(v) {
18771                         if canChange {
18772                                 v = append(v, 0)
18773                                 changed = true
18774                         } else {
18775                                 d.arrayCannotExpand(len(v), j+1)
18776                                 decodeIntoBlank = true
18777                         }
18778                 }
18779                 slh.ElemContainerState(j)
18780                 if decodeIntoBlank {
18781                         d.swallow()
18782                 } else if dd.TryDecodeAsNil() {
18783                         v[j] = 0
18784                 } else {
18785                         v[j] = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
18786                 }
18787         }
18788         if canChange {
18789                 if j < len(v) {
18790                         v = v[:j]
18791                         changed = true
18792                 } else if j == 0 && v == nil {
18793                         v = make([]int, 0)
18794                         changed = true
18795                 }
18796         }
18797         slh.End()
18798         d.depthDecr()
18799         return v, changed
18800 }
18801
18802 func (d *Decoder) fastpathDecSliceInt8R(f *codecFnInfo, rv reflect.Value) {
18803         if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18804                 vp := rv2i(rv).(*[]int8)
18805                 v, changed := fastpathTV.DecSliceInt8V(*vp, !array, d)
18806                 if changed {
18807                         *vp = v
18808                 }
18809         } else {
18810                 v := rv2i(rv).([]int8)
18811                 v2, changed := fastpathTV.DecSliceInt8V(v, !array, d)
18812                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18813                         copy(v, v2)
18814                 }
18815         }
18816 }
18817 func (f fastpathT) DecSliceInt8X(vp *[]int8, d *Decoder) {
18818         v, changed := f.DecSliceInt8V(*vp, true, d)
18819         if changed {
18820                 *vp = v
18821         }
18822 }
18823 func (_ fastpathT) DecSliceInt8V(v []int8, canChange bool, d *Decoder) (_ []int8, changed bool) {
18824         dd := d.d
18825         slh, containerLenS := d.decSliceHelperStart()
18826         if containerLenS == 0 {
18827                 if canChange {
18828                         if v == nil {
18829                                 v = []int8{}
18830                         } else if len(v) != 0 {
18831                                 v = v[:0]
18832                         }
18833                         changed = true
18834                 }
18835                 slh.End()
18836                 return v, changed
18837         }
18838         d.depthIncr()
18839         hasLen := containerLenS > 0
18840         var xlen int
18841         if hasLen && canChange {
18842                 if containerLenS > cap(v) {
18843                         xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
18844                         if xlen <= cap(v) {
18845                                 v = v[:xlen]
18846                         } else {
18847                                 v = make([]int8, xlen)
18848                         }
18849                         changed = true
18850                 } else if containerLenS != len(v) {
18851                         v = v[:containerLenS]
18852                         changed = true
18853                 }
18854         }
18855         j := 0
18856         for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18857                 if j == 0 && len(v) == 0 && canChange {
18858                         if hasLen {
18859                                 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
18860                         } else {
18861                                 xlen = 8
18862                         }
18863                         v = make([]int8, xlen)
18864                         changed = true
18865                 }
18866                 // if indefinite, etc, then expand the slice if necessary
18867                 var decodeIntoBlank bool
18868                 if j >= len(v) {
18869                         if canChange {
18870                                 v = append(v, 0)
18871                                 changed = true
18872                         } else {
18873                                 d.arrayCannotExpand(len(v), j+1)
18874                                 decodeIntoBlank = true
18875                         }
18876                 }
18877                 slh.ElemContainerState(j)
18878                 if decodeIntoBlank {
18879                         d.swallow()
18880                 } else if dd.TryDecodeAsNil() {
18881                         v[j] = 0
18882                 } else {
18883                         v[j] = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
18884                 }
18885         }
18886         if canChange {
18887                 if j < len(v) {
18888                         v = v[:j]
18889                         changed = true
18890                 } else if j == 0 && v == nil {
18891                         v = make([]int8, 0)
18892                         changed = true
18893                 }
18894         }
18895         slh.End()
18896         d.depthDecr()
18897         return v, changed
18898 }
18899
18900 func (d *Decoder) fastpathDecSliceInt16R(f *codecFnInfo, rv reflect.Value) {
18901         if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18902                 vp := rv2i(rv).(*[]int16)
18903                 v, changed := fastpathTV.DecSliceInt16V(*vp, !array, d)
18904                 if changed {
18905                         *vp = v
18906                 }
18907         } else {
18908                 v := rv2i(rv).([]int16)
18909                 v2, changed := fastpathTV.DecSliceInt16V(v, !array, d)
18910                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18911                         copy(v, v2)
18912                 }
18913         }
18914 }
18915 func (f fastpathT) DecSliceInt16X(vp *[]int16, d *Decoder) {
18916         v, changed := f.DecSliceInt16V(*vp, true, d)
18917         if changed {
18918                 *vp = v
18919         }
18920 }
18921 func (_ fastpathT) DecSliceInt16V(v []int16, canChange bool, d *Decoder) (_ []int16, changed bool) {
18922         dd := d.d
18923         slh, containerLenS := d.decSliceHelperStart()
18924         if containerLenS == 0 {
18925                 if canChange {
18926                         if v == nil {
18927                                 v = []int16{}
18928                         } else if len(v) != 0 {
18929                                 v = v[:0]
18930                         }
18931                         changed = true
18932                 }
18933                 slh.End()
18934                 return v, changed
18935         }
18936         d.depthIncr()
18937         hasLen := containerLenS > 0
18938         var xlen int
18939         if hasLen && canChange {
18940                 if containerLenS > cap(v) {
18941                         xlen = decInferLen(containerLenS, d.h.MaxInitLen, 2)
18942                         if xlen <= cap(v) {
18943                                 v = v[:xlen]
18944                         } else {
18945                                 v = make([]int16, xlen)
18946                         }
18947                         changed = true
18948                 } else if containerLenS != len(v) {
18949                         v = v[:containerLenS]
18950                         changed = true
18951                 }
18952         }
18953         j := 0
18954         for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18955                 if j == 0 && len(v) == 0 && canChange {
18956                         if hasLen {
18957                                 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 2)
18958                         } else {
18959                                 xlen = 8
18960                         }
18961                         v = make([]int16, xlen)
18962                         changed = true
18963                 }
18964                 // if indefinite, etc, then expand the slice if necessary
18965                 var decodeIntoBlank bool
18966                 if j >= len(v) {
18967                         if canChange {
18968                                 v = append(v, 0)
18969                                 changed = true
18970                         } else {
18971                                 d.arrayCannotExpand(len(v), j+1)
18972                                 decodeIntoBlank = true
18973                         }
18974                 }
18975                 slh.ElemContainerState(j)
18976                 if decodeIntoBlank {
18977                         d.swallow()
18978                 } else if dd.TryDecodeAsNil() {
18979                         v[j] = 0
18980                 } else {
18981                         v[j] = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
18982                 }
18983         }
18984         if canChange {
18985                 if j < len(v) {
18986                         v = v[:j]
18987                         changed = true
18988                 } else if j == 0 && v == nil {
18989                         v = make([]int16, 0)
18990                         changed = true
18991                 }
18992         }
18993         slh.End()
18994         d.depthDecr()
18995         return v, changed
18996 }
18997
18998 func (d *Decoder) fastpathDecSliceInt32R(f *codecFnInfo, rv reflect.Value) {
18999         if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
19000                 vp := rv2i(rv).(*[]int32)
19001                 v, changed := fastpathTV.DecSliceInt32V(*vp, !array, d)
19002                 if changed {
19003                         *vp = v
19004                 }
19005         } else {
19006                 v := rv2i(rv).([]int32)
19007                 v2, changed := fastpathTV.DecSliceInt32V(v, !array, d)
19008                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
19009                         copy(v, v2)
19010                 }
19011         }
19012 }
19013 func (f fastpathT) DecSliceInt32X(vp *[]int32, d *Decoder) {
19014         v, changed := f.DecSliceInt32V(*vp, true, d)
19015         if changed {
19016                 *vp = v
19017         }
19018 }
19019 func (_ fastpathT) DecSliceInt32V(v []int32, canChange bool, d *Decoder) (_ []int32, changed bool) {
19020         dd := d.d
19021         slh, containerLenS := d.decSliceHelperStart()
19022         if containerLenS == 0 {
19023                 if canChange {
19024                         if v == nil {
19025                                 v = []int32{}
19026                         } else if len(v) != 0 {
19027                                 v = v[:0]
19028                         }
19029                         changed = true
19030                 }
19031                 slh.End()
19032                 return v, changed
19033         }
19034         d.depthIncr()
19035         hasLen := containerLenS > 0
19036         var xlen int
19037         if hasLen && canChange {
19038                 if containerLenS > cap(v) {
19039                         xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
19040                         if xlen <= cap(v) {
19041                                 v = v[:xlen]
19042                         } else {
19043                                 v = make([]int32, xlen)
19044                         }
19045                         changed = true
19046                 } else if containerLenS != len(v) {
19047                         v = v[:containerLenS]
19048                         changed = true
19049                 }
19050         }
19051         j := 0
19052         for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
19053                 if j == 0 && len(v) == 0 && canChange {
19054                         if hasLen {
19055                                 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
19056                         } else {
19057                                 xlen = 8
19058                         }
19059                         v = make([]int32, xlen)
19060                         changed = true
19061                 }
19062                 // if indefinite, etc, then expand the slice if necessary
19063                 var decodeIntoBlank bool
19064                 if j >= len(v) {
19065                         if canChange {
19066                                 v = append(v, 0)
19067                                 changed = true
19068                         } else {
19069                                 d.arrayCannotExpand(len(v), j+1)
19070                                 decodeIntoBlank = true
19071                         }
19072                 }
19073                 slh.ElemContainerState(j)
19074                 if decodeIntoBlank {
19075                         d.swallow()
19076                 } else if dd.TryDecodeAsNil() {
19077                         v[j] = 0
19078                 } else {
19079                         v[j] = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
19080                 }
19081         }
19082         if canChange {
19083                 if j < len(v) {
19084                         v = v[:j]
19085                         changed = true
19086                 } else if j == 0 && v == nil {
19087                         v = make([]int32, 0)
19088                         changed = true
19089                 }
19090         }
19091         slh.End()
19092         d.depthDecr()
19093         return v, changed
19094 }
19095
19096 func (d *Decoder) fastpathDecSliceInt64R(f *codecFnInfo, rv reflect.Value) {
19097         if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
19098                 vp := rv2i(rv).(*[]int64)
19099                 v, changed := fastpathTV.DecSliceInt64V(*vp, !array, d)
19100                 if changed {
19101                         *vp = v
19102                 }
19103         } else {
19104                 v := rv2i(rv).([]int64)
19105                 v2, changed := fastpathTV.DecSliceInt64V(v, !array, d)
19106                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
19107                         copy(v, v2)
19108                 }
19109         }
19110 }
19111 func (f fastpathT) DecSliceInt64X(vp *[]int64, d *Decoder) {
19112         v, changed := f.DecSliceInt64V(*vp, true, d)
19113         if changed {
19114                 *vp = v
19115         }
19116 }
19117 func (_ fastpathT) DecSliceInt64V(v []int64, canChange bool, d *Decoder) (_ []int64, changed bool) {
19118         dd := d.d
19119         slh, containerLenS := d.decSliceHelperStart()
19120         if containerLenS == 0 {
19121                 if canChange {
19122                         if v == nil {
19123                                 v = []int64{}
19124                         } else if len(v) != 0 {
19125                                 v = v[:0]
19126                         }
19127                         changed = true
19128                 }
19129                 slh.End()
19130                 return v, changed
19131         }
19132         d.depthIncr()
19133         hasLen := containerLenS > 0
19134         var xlen int
19135         if hasLen && canChange {
19136                 if containerLenS > cap(v) {
19137                         xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
19138                         if xlen <= cap(v) {
19139                                 v = v[:xlen]
19140                         } else {
19141                                 v = make([]int64, xlen)
19142                         }
19143                         changed = true
19144                 } else if containerLenS != len(v) {
19145                         v = v[:containerLenS]
19146                         changed = true
19147                 }
19148         }
19149         j := 0
19150         for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
19151                 if j == 0 && len(v) == 0 && canChange {
19152                         if hasLen {
19153                                 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
19154                         } else {
19155                                 xlen = 8
19156                         }
19157                         v = make([]int64, xlen)
19158                         changed = true
19159                 }
19160                 // if indefinite, etc, then expand the slice if necessary
19161                 var decodeIntoBlank bool
19162                 if j >= len(v) {
19163                         if canChange {
19164                                 v = append(v, 0)
19165                                 changed = true
19166                         } else {
19167                                 d.arrayCannotExpand(len(v), j+1)
19168                                 decodeIntoBlank = true
19169                         }
19170                 }
19171                 slh.ElemContainerState(j)
19172                 if decodeIntoBlank {
19173                         d.swallow()
19174                 } else if dd.TryDecodeAsNil() {
19175                         v[j] = 0
19176                 } else {
19177                         v[j] = dd.DecodeInt64()
19178                 }
19179         }
19180         if canChange {
19181                 if j < len(v) {
19182                         v = v[:j]
19183                         changed = true
19184                 } else if j == 0 && v == nil {
19185                         v = make([]int64, 0)
19186                         changed = true
19187                 }
19188         }
19189         slh.End()
19190         d.depthDecr()
19191         return v, changed
19192 }
19193
19194 func (d *Decoder) fastpathDecSliceBoolR(f *codecFnInfo, rv reflect.Value) {
19195         if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
19196                 vp := rv2i(rv).(*[]bool)
19197                 v, changed := fastpathTV.DecSliceBoolV(*vp, !array, d)
19198                 if changed {
19199                         *vp = v
19200                 }
19201         } else {
19202                 v := rv2i(rv).([]bool)
19203                 v2, changed := fastpathTV.DecSliceBoolV(v, !array, d)
19204                 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
19205                         copy(v, v2)
19206                 }
19207         }
19208 }
19209 func (f fastpathT) DecSliceBoolX(vp *[]bool, d *Decoder) {
19210         v, changed := f.DecSliceBoolV(*vp, true, d)
19211         if changed {
19212                 *vp = v
19213         }
19214 }
19215 func (_ fastpathT) DecSliceBoolV(v []bool, canChange bool, d *Decoder) (_ []bool, changed bool) {
19216         dd := d.d
19217         slh, containerLenS := d.decSliceHelperStart()
19218         if containerLenS == 0 {
19219                 if canChange {
19220                         if v == nil {
19221                                 v = []bool{}
19222                         } else if len(v) != 0 {
19223                                 v = v[:0]
19224                         }
19225                         changed = true
19226                 }
19227                 slh.End()
19228                 return v, changed
19229         }
19230         d.depthIncr()
19231         hasLen := containerLenS > 0
19232         var xlen int
19233         if hasLen && canChange {
19234                 if containerLenS > cap(v) {
19235                         xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
19236                         if xlen <= cap(v) {
19237                                 v = v[:xlen]
19238                         } else {
19239                                 v = make([]bool, xlen)
19240                         }
19241                         changed = true
19242                 } else if containerLenS != len(v) {
19243                         v = v[:containerLenS]
19244                         changed = true
19245                 }
19246         }
19247         j := 0
19248         for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
19249                 if j == 0 && len(v) == 0 && canChange {
19250                         if hasLen {
19251                                 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
19252                         } else {
19253                                 xlen = 8
19254                         }
19255                         v = make([]bool, xlen)
19256                         changed = true
19257                 }
19258                 // if indefinite, etc, then expand the slice if necessary
19259                 var decodeIntoBlank bool
19260                 if j >= len(v) {
19261                         if canChange {
19262                                 v = append(v, false)
19263                                 changed = true
19264                         } else {
19265                                 d.arrayCannotExpand(len(v), j+1)
19266                                 decodeIntoBlank = true
19267                         }
19268                 }
19269                 slh.ElemContainerState(j)
19270                 if decodeIntoBlank {
19271                         d.swallow()
19272                 } else if dd.TryDecodeAsNil() {
19273                         v[j] = false
19274                 } else {
19275                         v[j] = dd.DecodeBool()
19276                 }
19277         }
19278         if canChange {
19279                 if j < len(v) {
19280                         v = v[:j]
19281                         changed = true
19282                 } else if j == 0 && v == nil {
19283                         v = make([]bool, 0)
19284                         changed = true
19285                 }
19286         }
19287         slh.End()
19288         d.depthDecr()
19289         return v, changed
19290 }
19291
19292 func (d *Decoder) fastpathDecMapIntfIntfR(f *codecFnInfo, rv reflect.Value) {
19293         if rv.Kind() == reflect.Ptr {
19294                 vp := rv2i(rv).(*map[interface{}]interface{})
19295                 v, changed := fastpathTV.DecMapIntfIntfV(*vp, true, d)
19296                 if changed {
19297                         *vp = v
19298                 }
19299         } else {
19300                 fastpathTV.DecMapIntfIntfV(rv2i(rv).(map[interface{}]interface{}), false, d)
19301         }
19302 }
19303 func (f fastpathT) DecMapIntfIntfX(vp *map[interface{}]interface{}, d *Decoder) {
19304         v, changed := f.DecMapIntfIntfV(*vp, true, d)
19305         if changed {
19306                 *vp = v
19307         }
19308 }
19309 func (_ fastpathT) DecMapIntfIntfV(v map[interface{}]interface{}, canChange bool,
19310         d *Decoder) (_ map[interface{}]interface{}, changed bool) {
19311         dd, esep := d.d, d.hh.hasElemSeparators()
19312         containerLen := dd.ReadMapStart()
19313         if canChange && v == nil {
19314                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 32)
19315                 v = make(map[interface{}]interface{}, xlen)
19316                 changed = true
19317         }
19318         if containerLen == 0 {
19319                 dd.ReadMapEnd()
19320                 return v, changed
19321         }
19322         d.depthIncr()
19323         mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
19324         var mk interface{}
19325         var mv interface{}
19326         hasLen := containerLen > 0
19327         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19328                 if esep {
19329                         dd.ReadMapElemKey()
19330                 }
19331                 mk = nil
19332                 d.decode(&mk)
19333                 if bv, bok := mk.([]byte); bok {
19334                         mk = d.string(bv)
19335                 }
19336                 if esep {
19337                         dd.ReadMapElemValue()
19338                 }
19339                 if dd.TryDecodeAsNil() {
19340                         if v == nil {
19341                         } else if d.h.DeleteOnNilMapValue {
19342                                 delete(v, mk)
19343                         } else {
19344                                 v[mk] = nil
19345                         }
19346                         continue
19347                 }
19348                 if mapGet {
19349                         mv = v[mk]
19350                 } else {
19351                         mv = nil
19352                 }
19353                 d.decode(&mv)
19354                 if v != nil {
19355                         v[mk] = mv
19356                 }
19357         }
19358         dd.ReadMapEnd()
19359         d.depthDecr()
19360         return v, changed
19361 }
19362
19363 func (d *Decoder) fastpathDecMapIntfStringR(f *codecFnInfo, rv reflect.Value) {
19364         if rv.Kind() == reflect.Ptr {
19365                 vp := rv2i(rv).(*map[interface{}]string)
19366                 v, changed := fastpathTV.DecMapIntfStringV(*vp, true, d)
19367                 if changed {
19368                         *vp = v
19369                 }
19370         } else {
19371                 fastpathTV.DecMapIntfStringV(rv2i(rv).(map[interface{}]string), false, d)
19372         }
19373 }
19374 func (f fastpathT) DecMapIntfStringX(vp *map[interface{}]string, d *Decoder) {
19375         v, changed := f.DecMapIntfStringV(*vp, true, d)
19376         if changed {
19377                 *vp = v
19378         }
19379 }
19380 func (_ fastpathT) DecMapIntfStringV(v map[interface{}]string, canChange bool,
19381         d *Decoder) (_ map[interface{}]string, changed bool) {
19382         dd, esep := d.d, d.hh.hasElemSeparators()
19383         containerLen := dd.ReadMapStart()
19384         if canChange && v == nil {
19385                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 32)
19386                 v = make(map[interface{}]string, xlen)
19387                 changed = true
19388         }
19389         if containerLen == 0 {
19390                 dd.ReadMapEnd()
19391                 return v, changed
19392         }
19393         d.depthIncr()
19394         var mk interface{}
19395         var mv string
19396         hasLen := containerLen > 0
19397         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19398                 if esep {
19399                         dd.ReadMapElemKey()
19400                 }
19401                 mk = nil
19402                 d.decode(&mk)
19403                 if bv, bok := mk.([]byte); bok {
19404                         mk = d.string(bv)
19405                 }
19406                 if esep {
19407                         dd.ReadMapElemValue()
19408                 }
19409                 if dd.TryDecodeAsNil() {
19410                         if v == nil {
19411                         } else if d.h.DeleteOnNilMapValue {
19412                                 delete(v, mk)
19413                         } else {
19414                                 v[mk] = ""
19415                         }
19416                         continue
19417                 }
19418                 mv = dd.DecodeString()
19419                 if v != nil {
19420                         v[mk] = mv
19421                 }
19422         }
19423         dd.ReadMapEnd()
19424         d.depthDecr()
19425         return v, changed
19426 }
19427
19428 func (d *Decoder) fastpathDecMapIntfUintR(f *codecFnInfo, rv reflect.Value) {
19429         if rv.Kind() == reflect.Ptr {
19430                 vp := rv2i(rv).(*map[interface{}]uint)
19431                 v, changed := fastpathTV.DecMapIntfUintV(*vp, true, d)
19432                 if changed {
19433                         *vp = v
19434                 }
19435         } else {
19436                 fastpathTV.DecMapIntfUintV(rv2i(rv).(map[interface{}]uint), false, d)
19437         }
19438 }
19439 func (f fastpathT) DecMapIntfUintX(vp *map[interface{}]uint, d *Decoder) {
19440         v, changed := f.DecMapIntfUintV(*vp, true, d)
19441         if changed {
19442                 *vp = v
19443         }
19444 }
19445 func (_ fastpathT) DecMapIntfUintV(v map[interface{}]uint, canChange bool,
19446         d *Decoder) (_ map[interface{}]uint, changed bool) {
19447         dd, esep := d.d, d.hh.hasElemSeparators()
19448         containerLen := dd.ReadMapStart()
19449         if canChange && v == nil {
19450                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
19451                 v = make(map[interface{}]uint, xlen)
19452                 changed = true
19453         }
19454         if containerLen == 0 {
19455                 dd.ReadMapEnd()
19456                 return v, changed
19457         }
19458         d.depthIncr()
19459         var mk interface{}
19460         var mv uint
19461         hasLen := containerLen > 0
19462         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19463                 if esep {
19464                         dd.ReadMapElemKey()
19465                 }
19466                 mk = nil
19467                 d.decode(&mk)
19468                 if bv, bok := mk.([]byte); bok {
19469                         mk = d.string(bv)
19470                 }
19471                 if esep {
19472                         dd.ReadMapElemValue()
19473                 }
19474                 if dd.TryDecodeAsNil() {
19475                         if v == nil {
19476                         } else if d.h.DeleteOnNilMapValue {
19477                                 delete(v, mk)
19478                         } else {
19479                                 v[mk] = 0
19480                         }
19481                         continue
19482                 }
19483                 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
19484                 if v != nil {
19485                         v[mk] = mv
19486                 }
19487         }
19488         dd.ReadMapEnd()
19489         d.depthDecr()
19490         return v, changed
19491 }
19492
19493 func (d *Decoder) fastpathDecMapIntfUint8R(f *codecFnInfo, rv reflect.Value) {
19494         if rv.Kind() == reflect.Ptr {
19495                 vp := rv2i(rv).(*map[interface{}]uint8)
19496                 v, changed := fastpathTV.DecMapIntfUint8V(*vp, true, d)
19497                 if changed {
19498                         *vp = v
19499                 }
19500         } else {
19501                 fastpathTV.DecMapIntfUint8V(rv2i(rv).(map[interface{}]uint8), false, d)
19502         }
19503 }
19504 func (f fastpathT) DecMapIntfUint8X(vp *map[interface{}]uint8, d *Decoder) {
19505         v, changed := f.DecMapIntfUint8V(*vp, true, d)
19506         if changed {
19507                 *vp = v
19508         }
19509 }
19510 func (_ fastpathT) DecMapIntfUint8V(v map[interface{}]uint8, canChange bool,
19511         d *Decoder) (_ map[interface{}]uint8, changed bool) {
19512         dd, esep := d.d, d.hh.hasElemSeparators()
19513         containerLen := dd.ReadMapStart()
19514         if canChange && v == nil {
19515                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
19516                 v = make(map[interface{}]uint8, xlen)
19517                 changed = true
19518         }
19519         if containerLen == 0 {
19520                 dd.ReadMapEnd()
19521                 return v, changed
19522         }
19523         d.depthIncr()
19524         var mk interface{}
19525         var mv uint8
19526         hasLen := containerLen > 0
19527         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19528                 if esep {
19529                         dd.ReadMapElemKey()
19530                 }
19531                 mk = nil
19532                 d.decode(&mk)
19533                 if bv, bok := mk.([]byte); bok {
19534                         mk = d.string(bv)
19535                 }
19536                 if esep {
19537                         dd.ReadMapElemValue()
19538                 }
19539                 if dd.TryDecodeAsNil() {
19540                         if v == nil {
19541                         } else if d.h.DeleteOnNilMapValue {
19542                                 delete(v, mk)
19543                         } else {
19544                                 v[mk] = 0
19545                         }
19546                         continue
19547                 }
19548                 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
19549                 if v != nil {
19550                         v[mk] = mv
19551                 }
19552         }
19553         dd.ReadMapEnd()
19554         d.depthDecr()
19555         return v, changed
19556 }
19557
19558 func (d *Decoder) fastpathDecMapIntfUint16R(f *codecFnInfo, rv reflect.Value) {
19559         if rv.Kind() == reflect.Ptr {
19560                 vp := rv2i(rv).(*map[interface{}]uint16)
19561                 v, changed := fastpathTV.DecMapIntfUint16V(*vp, true, d)
19562                 if changed {
19563                         *vp = v
19564                 }
19565         } else {
19566                 fastpathTV.DecMapIntfUint16V(rv2i(rv).(map[interface{}]uint16), false, d)
19567         }
19568 }
19569 func (f fastpathT) DecMapIntfUint16X(vp *map[interface{}]uint16, d *Decoder) {
19570         v, changed := f.DecMapIntfUint16V(*vp, true, d)
19571         if changed {
19572                 *vp = v
19573         }
19574 }
19575 func (_ fastpathT) DecMapIntfUint16V(v map[interface{}]uint16, canChange bool,
19576         d *Decoder) (_ map[interface{}]uint16, changed bool) {
19577         dd, esep := d.d, d.hh.hasElemSeparators()
19578         containerLen := dd.ReadMapStart()
19579         if canChange && v == nil {
19580                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
19581                 v = make(map[interface{}]uint16, xlen)
19582                 changed = true
19583         }
19584         if containerLen == 0 {
19585                 dd.ReadMapEnd()
19586                 return v, changed
19587         }
19588         d.depthIncr()
19589         var mk interface{}
19590         var mv uint16
19591         hasLen := containerLen > 0
19592         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19593                 if esep {
19594                         dd.ReadMapElemKey()
19595                 }
19596                 mk = nil
19597                 d.decode(&mk)
19598                 if bv, bok := mk.([]byte); bok {
19599                         mk = d.string(bv)
19600                 }
19601                 if esep {
19602                         dd.ReadMapElemValue()
19603                 }
19604                 if dd.TryDecodeAsNil() {
19605                         if v == nil {
19606                         } else if d.h.DeleteOnNilMapValue {
19607                                 delete(v, mk)
19608                         } else {
19609                                 v[mk] = 0
19610                         }
19611                         continue
19612                 }
19613                 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
19614                 if v != nil {
19615                         v[mk] = mv
19616                 }
19617         }
19618         dd.ReadMapEnd()
19619         d.depthDecr()
19620         return v, changed
19621 }
19622
19623 func (d *Decoder) fastpathDecMapIntfUint32R(f *codecFnInfo, rv reflect.Value) {
19624         if rv.Kind() == reflect.Ptr {
19625                 vp := rv2i(rv).(*map[interface{}]uint32)
19626                 v, changed := fastpathTV.DecMapIntfUint32V(*vp, true, d)
19627                 if changed {
19628                         *vp = v
19629                 }
19630         } else {
19631                 fastpathTV.DecMapIntfUint32V(rv2i(rv).(map[interface{}]uint32), false, d)
19632         }
19633 }
19634 func (f fastpathT) DecMapIntfUint32X(vp *map[interface{}]uint32, d *Decoder) {
19635         v, changed := f.DecMapIntfUint32V(*vp, true, d)
19636         if changed {
19637                 *vp = v
19638         }
19639 }
19640 func (_ fastpathT) DecMapIntfUint32V(v map[interface{}]uint32, canChange bool,
19641         d *Decoder) (_ map[interface{}]uint32, changed bool) {
19642         dd, esep := d.d, d.hh.hasElemSeparators()
19643         containerLen := dd.ReadMapStart()
19644         if canChange && v == nil {
19645                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
19646                 v = make(map[interface{}]uint32, xlen)
19647                 changed = true
19648         }
19649         if containerLen == 0 {
19650                 dd.ReadMapEnd()
19651                 return v, changed
19652         }
19653         d.depthIncr()
19654         var mk interface{}
19655         var mv uint32
19656         hasLen := containerLen > 0
19657         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19658                 if esep {
19659                         dd.ReadMapElemKey()
19660                 }
19661                 mk = nil
19662                 d.decode(&mk)
19663                 if bv, bok := mk.([]byte); bok {
19664                         mk = d.string(bv)
19665                 }
19666                 if esep {
19667                         dd.ReadMapElemValue()
19668                 }
19669                 if dd.TryDecodeAsNil() {
19670                         if v == nil {
19671                         } else if d.h.DeleteOnNilMapValue {
19672                                 delete(v, mk)
19673                         } else {
19674                                 v[mk] = 0
19675                         }
19676                         continue
19677                 }
19678                 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
19679                 if v != nil {
19680                         v[mk] = mv
19681                 }
19682         }
19683         dd.ReadMapEnd()
19684         d.depthDecr()
19685         return v, changed
19686 }
19687
19688 func (d *Decoder) fastpathDecMapIntfUint64R(f *codecFnInfo, rv reflect.Value) {
19689         if rv.Kind() == reflect.Ptr {
19690                 vp := rv2i(rv).(*map[interface{}]uint64)
19691                 v, changed := fastpathTV.DecMapIntfUint64V(*vp, true, d)
19692                 if changed {
19693                         *vp = v
19694                 }
19695         } else {
19696                 fastpathTV.DecMapIntfUint64V(rv2i(rv).(map[interface{}]uint64), false, d)
19697         }
19698 }
19699 func (f fastpathT) DecMapIntfUint64X(vp *map[interface{}]uint64, d *Decoder) {
19700         v, changed := f.DecMapIntfUint64V(*vp, true, d)
19701         if changed {
19702                 *vp = v
19703         }
19704 }
19705 func (_ fastpathT) DecMapIntfUint64V(v map[interface{}]uint64, canChange bool,
19706         d *Decoder) (_ map[interface{}]uint64, changed bool) {
19707         dd, esep := d.d, d.hh.hasElemSeparators()
19708         containerLen := dd.ReadMapStart()
19709         if canChange && v == nil {
19710                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
19711                 v = make(map[interface{}]uint64, xlen)
19712                 changed = true
19713         }
19714         if containerLen == 0 {
19715                 dd.ReadMapEnd()
19716                 return v, changed
19717         }
19718         d.depthIncr()
19719         var mk interface{}
19720         var mv uint64
19721         hasLen := containerLen > 0
19722         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19723                 if esep {
19724                         dd.ReadMapElemKey()
19725                 }
19726                 mk = nil
19727                 d.decode(&mk)
19728                 if bv, bok := mk.([]byte); bok {
19729                         mk = d.string(bv)
19730                 }
19731                 if esep {
19732                         dd.ReadMapElemValue()
19733                 }
19734                 if dd.TryDecodeAsNil() {
19735                         if v == nil {
19736                         } else if d.h.DeleteOnNilMapValue {
19737                                 delete(v, mk)
19738                         } else {
19739                                 v[mk] = 0
19740                         }
19741                         continue
19742                 }
19743                 mv = dd.DecodeUint64()
19744                 if v != nil {
19745                         v[mk] = mv
19746                 }
19747         }
19748         dd.ReadMapEnd()
19749         d.depthDecr()
19750         return v, changed
19751 }
19752
19753 func (d *Decoder) fastpathDecMapIntfUintptrR(f *codecFnInfo, rv reflect.Value) {
19754         if rv.Kind() == reflect.Ptr {
19755                 vp := rv2i(rv).(*map[interface{}]uintptr)
19756                 v, changed := fastpathTV.DecMapIntfUintptrV(*vp, true, d)
19757                 if changed {
19758                         *vp = v
19759                 }
19760         } else {
19761                 fastpathTV.DecMapIntfUintptrV(rv2i(rv).(map[interface{}]uintptr), false, d)
19762         }
19763 }
19764 func (f fastpathT) DecMapIntfUintptrX(vp *map[interface{}]uintptr, d *Decoder) {
19765         v, changed := f.DecMapIntfUintptrV(*vp, true, d)
19766         if changed {
19767                 *vp = v
19768         }
19769 }
19770 func (_ fastpathT) DecMapIntfUintptrV(v map[interface{}]uintptr, canChange bool,
19771         d *Decoder) (_ map[interface{}]uintptr, changed bool) {
19772         dd, esep := d.d, d.hh.hasElemSeparators()
19773         containerLen := dd.ReadMapStart()
19774         if canChange && v == nil {
19775                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
19776                 v = make(map[interface{}]uintptr, xlen)
19777                 changed = true
19778         }
19779         if containerLen == 0 {
19780                 dd.ReadMapEnd()
19781                 return v, changed
19782         }
19783         d.depthIncr()
19784         var mk interface{}
19785         var mv uintptr
19786         hasLen := containerLen > 0
19787         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19788                 if esep {
19789                         dd.ReadMapElemKey()
19790                 }
19791                 mk = nil
19792                 d.decode(&mk)
19793                 if bv, bok := mk.([]byte); bok {
19794                         mk = d.string(bv)
19795                 }
19796                 if esep {
19797                         dd.ReadMapElemValue()
19798                 }
19799                 if dd.TryDecodeAsNil() {
19800                         if v == nil {
19801                         } else if d.h.DeleteOnNilMapValue {
19802                                 delete(v, mk)
19803                         } else {
19804                                 v[mk] = 0
19805                         }
19806                         continue
19807                 }
19808                 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
19809                 if v != nil {
19810                         v[mk] = mv
19811                 }
19812         }
19813         dd.ReadMapEnd()
19814         d.depthDecr()
19815         return v, changed
19816 }
19817
19818 func (d *Decoder) fastpathDecMapIntfIntR(f *codecFnInfo, rv reflect.Value) {
19819         if rv.Kind() == reflect.Ptr {
19820                 vp := rv2i(rv).(*map[interface{}]int)
19821                 v, changed := fastpathTV.DecMapIntfIntV(*vp, true, d)
19822                 if changed {
19823                         *vp = v
19824                 }
19825         } else {
19826                 fastpathTV.DecMapIntfIntV(rv2i(rv).(map[interface{}]int), false, d)
19827         }
19828 }
19829 func (f fastpathT) DecMapIntfIntX(vp *map[interface{}]int, d *Decoder) {
19830         v, changed := f.DecMapIntfIntV(*vp, true, d)
19831         if changed {
19832                 *vp = v
19833         }
19834 }
19835 func (_ fastpathT) DecMapIntfIntV(v map[interface{}]int, canChange bool,
19836         d *Decoder) (_ map[interface{}]int, changed bool) {
19837         dd, esep := d.d, d.hh.hasElemSeparators()
19838         containerLen := dd.ReadMapStart()
19839         if canChange && v == nil {
19840                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
19841                 v = make(map[interface{}]int, xlen)
19842                 changed = true
19843         }
19844         if containerLen == 0 {
19845                 dd.ReadMapEnd()
19846                 return v, changed
19847         }
19848         d.depthIncr()
19849         var mk interface{}
19850         var mv int
19851         hasLen := containerLen > 0
19852         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19853                 if esep {
19854                         dd.ReadMapElemKey()
19855                 }
19856                 mk = nil
19857                 d.decode(&mk)
19858                 if bv, bok := mk.([]byte); bok {
19859                         mk = d.string(bv)
19860                 }
19861                 if esep {
19862                         dd.ReadMapElemValue()
19863                 }
19864                 if dd.TryDecodeAsNil() {
19865                         if v == nil {
19866                         } else if d.h.DeleteOnNilMapValue {
19867                                 delete(v, mk)
19868                         } else {
19869                                 v[mk] = 0
19870                         }
19871                         continue
19872                 }
19873                 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
19874                 if v != nil {
19875                         v[mk] = mv
19876                 }
19877         }
19878         dd.ReadMapEnd()
19879         d.depthDecr()
19880         return v, changed
19881 }
19882
19883 func (d *Decoder) fastpathDecMapIntfInt8R(f *codecFnInfo, rv reflect.Value) {
19884         if rv.Kind() == reflect.Ptr {
19885                 vp := rv2i(rv).(*map[interface{}]int8)
19886                 v, changed := fastpathTV.DecMapIntfInt8V(*vp, true, d)
19887                 if changed {
19888                         *vp = v
19889                 }
19890         } else {
19891                 fastpathTV.DecMapIntfInt8V(rv2i(rv).(map[interface{}]int8), false, d)
19892         }
19893 }
19894 func (f fastpathT) DecMapIntfInt8X(vp *map[interface{}]int8, d *Decoder) {
19895         v, changed := f.DecMapIntfInt8V(*vp, true, d)
19896         if changed {
19897                 *vp = v
19898         }
19899 }
19900 func (_ fastpathT) DecMapIntfInt8V(v map[interface{}]int8, canChange bool,
19901         d *Decoder) (_ map[interface{}]int8, changed bool) {
19902         dd, esep := d.d, d.hh.hasElemSeparators()
19903         containerLen := dd.ReadMapStart()
19904         if canChange && v == nil {
19905                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
19906                 v = make(map[interface{}]int8, xlen)
19907                 changed = true
19908         }
19909         if containerLen == 0 {
19910                 dd.ReadMapEnd()
19911                 return v, changed
19912         }
19913         d.depthIncr()
19914         var mk interface{}
19915         var mv int8
19916         hasLen := containerLen > 0
19917         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19918                 if esep {
19919                         dd.ReadMapElemKey()
19920                 }
19921                 mk = nil
19922                 d.decode(&mk)
19923                 if bv, bok := mk.([]byte); bok {
19924                         mk = d.string(bv)
19925                 }
19926                 if esep {
19927                         dd.ReadMapElemValue()
19928                 }
19929                 if dd.TryDecodeAsNil() {
19930                         if v == nil {
19931                         } else if d.h.DeleteOnNilMapValue {
19932                                 delete(v, mk)
19933                         } else {
19934                                 v[mk] = 0
19935                         }
19936                         continue
19937                 }
19938                 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
19939                 if v != nil {
19940                         v[mk] = mv
19941                 }
19942         }
19943         dd.ReadMapEnd()
19944         d.depthDecr()
19945         return v, changed
19946 }
19947
19948 func (d *Decoder) fastpathDecMapIntfInt16R(f *codecFnInfo, rv reflect.Value) {
19949         if rv.Kind() == reflect.Ptr {
19950                 vp := rv2i(rv).(*map[interface{}]int16)
19951                 v, changed := fastpathTV.DecMapIntfInt16V(*vp, true, d)
19952                 if changed {
19953                         *vp = v
19954                 }
19955         } else {
19956                 fastpathTV.DecMapIntfInt16V(rv2i(rv).(map[interface{}]int16), false, d)
19957         }
19958 }
19959 func (f fastpathT) DecMapIntfInt16X(vp *map[interface{}]int16, d *Decoder) {
19960         v, changed := f.DecMapIntfInt16V(*vp, true, d)
19961         if changed {
19962                 *vp = v
19963         }
19964 }
19965 func (_ fastpathT) DecMapIntfInt16V(v map[interface{}]int16, canChange bool,
19966         d *Decoder) (_ map[interface{}]int16, changed bool) {
19967         dd, esep := d.d, d.hh.hasElemSeparators()
19968         containerLen := dd.ReadMapStart()
19969         if canChange && v == nil {
19970                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
19971                 v = make(map[interface{}]int16, xlen)
19972                 changed = true
19973         }
19974         if containerLen == 0 {
19975                 dd.ReadMapEnd()
19976                 return v, changed
19977         }
19978         d.depthIncr()
19979         var mk interface{}
19980         var mv int16
19981         hasLen := containerLen > 0
19982         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19983                 if esep {
19984                         dd.ReadMapElemKey()
19985                 }
19986                 mk = nil
19987                 d.decode(&mk)
19988                 if bv, bok := mk.([]byte); bok {
19989                         mk = d.string(bv)
19990                 }
19991                 if esep {
19992                         dd.ReadMapElemValue()
19993                 }
19994                 if dd.TryDecodeAsNil() {
19995                         if v == nil {
19996                         } else if d.h.DeleteOnNilMapValue {
19997                                 delete(v, mk)
19998                         } else {
19999                                 v[mk] = 0
20000                         }
20001                         continue
20002                 }
20003                 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
20004                 if v != nil {
20005                         v[mk] = mv
20006                 }
20007         }
20008         dd.ReadMapEnd()
20009         d.depthDecr()
20010         return v, changed
20011 }
20012
20013 func (d *Decoder) fastpathDecMapIntfInt32R(f *codecFnInfo, rv reflect.Value) {
20014         if rv.Kind() == reflect.Ptr {
20015                 vp := rv2i(rv).(*map[interface{}]int32)
20016                 v, changed := fastpathTV.DecMapIntfInt32V(*vp, true, d)
20017                 if changed {
20018                         *vp = v
20019                 }
20020         } else {
20021                 fastpathTV.DecMapIntfInt32V(rv2i(rv).(map[interface{}]int32), false, d)
20022         }
20023 }
20024 func (f fastpathT) DecMapIntfInt32X(vp *map[interface{}]int32, d *Decoder) {
20025         v, changed := f.DecMapIntfInt32V(*vp, true, d)
20026         if changed {
20027                 *vp = v
20028         }
20029 }
20030 func (_ fastpathT) DecMapIntfInt32V(v map[interface{}]int32, canChange bool,
20031         d *Decoder) (_ map[interface{}]int32, changed bool) {
20032         dd, esep := d.d, d.hh.hasElemSeparators()
20033         containerLen := dd.ReadMapStart()
20034         if canChange && v == nil {
20035                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
20036                 v = make(map[interface{}]int32, xlen)
20037                 changed = true
20038         }
20039         if containerLen == 0 {
20040                 dd.ReadMapEnd()
20041                 return v, changed
20042         }
20043         d.depthIncr()
20044         var mk interface{}
20045         var mv int32
20046         hasLen := containerLen > 0
20047         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20048                 if esep {
20049                         dd.ReadMapElemKey()
20050                 }
20051                 mk = nil
20052                 d.decode(&mk)
20053                 if bv, bok := mk.([]byte); bok {
20054                         mk = d.string(bv)
20055                 }
20056                 if esep {
20057                         dd.ReadMapElemValue()
20058                 }
20059                 if dd.TryDecodeAsNil() {
20060                         if v == nil {
20061                         } else if d.h.DeleteOnNilMapValue {
20062                                 delete(v, mk)
20063                         } else {
20064                                 v[mk] = 0
20065                         }
20066                         continue
20067                 }
20068                 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
20069                 if v != nil {
20070                         v[mk] = mv
20071                 }
20072         }
20073         dd.ReadMapEnd()
20074         d.depthDecr()
20075         return v, changed
20076 }
20077
20078 func (d *Decoder) fastpathDecMapIntfInt64R(f *codecFnInfo, rv reflect.Value) {
20079         if rv.Kind() == reflect.Ptr {
20080                 vp := rv2i(rv).(*map[interface{}]int64)
20081                 v, changed := fastpathTV.DecMapIntfInt64V(*vp, true, d)
20082                 if changed {
20083                         *vp = v
20084                 }
20085         } else {
20086                 fastpathTV.DecMapIntfInt64V(rv2i(rv).(map[interface{}]int64), false, d)
20087         }
20088 }
20089 func (f fastpathT) DecMapIntfInt64X(vp *map[interface{}]int64, d *Decoder) {
20090         v, changed := f.DecMapIntfInt64V(*vp, true, d)
20091         if changed {
20092                 *vp = v
20093         }
20094 }
20095 func (_ fastpathT) DecMapIntfInt64V(v map[interface{}]int64, canChange bool,
20096         d *Decoder) (_ map[interface{}]int64, changed bool) {
20097         dd, esep := d.d, d.hh.hasElemSeparators()
20098         containerLen := dd.ReadMapStart()
20099         if canChange && v == nil {
20100                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
20101                 v = make(map[interface{}]int64, xlen)
20102                 changed = true
20103         }
20104         if containerLen == 0 {
20105                 dd.ReadMapEnd()
20106                 return v, changed
20107         }
20108         d.depthIncr()
20109         var mk interface{}
20110         var mv int64
20111         hasLen := containerLen > 0
20112         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20113                 if esep {
20114                         dd.ReadMapElemKey()
20115                 }
20116                 mk = nil
20117                 d.decode(&mk)
20118                 if bv, bok := mk.([]byte); bok {
20119                         mk = d.string(bv)
20120                 }
20121                 if esep {
20122                         dd.ReadMapElemValue()
20123                 }
20124                 if dd.TryDecodeAsNil() {
20125                         if v == nil {
20126                         } else if d.h.DeleteOnNilMapValue {
20127                                 delete(v, mk)
20128                         } else {
20129                                 v[mk] = 0
20130                         }
20131                         continue
20132                 }
20133                 mv = dd.DecodeInt64()
20134                 if v != nil {
20135                         v[mk] = mv
20136                 }
20137         }
20138         dd.ReadMapEnd()
20139         d.depthDecr()
20140         return v, changed
20141 }
20142
20143 func (d *Decoder) fastpathDecMapIntfFloat32R(f *codecFnInfo, rv reflect.Value) {
20144         if rv.Kind() == reflect.Ptr {
20145                 vp := rv2i(rv).(*map[interface{}]float32)
20146                 v, changed := fastpathTV.DecMapIntfFloat32V(*vp, true, d)
20147                 if changed {
20148                         *vp = v
20149                 }
20150         } else {
20151                 fastpathTV.DecMapIntfFloat32V(rv2i(rv).(map[interface{}]float32), false, d)
20152         }
20153 }
20154 func (f fastpathT) DecMapIntfFloat32X(vp *map[interface{}]float32, d *Decoder) {
20155         v, changed := f.DecMapIntfFloat32V(*vp, true, d)
20156         if changed {
20157                 *vp = v
20158         }
20159 }
20160 func (_ fastpathT) DecMapIntfFloat32V(v map[interface{}]float32, canChange bool,
20161         d *Decoder) (_ map[interface{}]float32, changed bool) {
20162         dd, esep := d.d, d.hh.hasElemSeparators()
20163         containerLen := dd.ReadMapStart()
20164         if canChange && v == nil {
20165                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
20166                 v = make(map[interface{}]float32, xlen)
20167                 changed = true
20168         }
20169         if containerLen == 0 {
20170                 dd.ReadMapEnd()
20171                 return v, changed
20172         }
20173         d.depthIncr()
20174         var mk interface{}
20175         var mv float32
20176         hasLen := containerLen > 0
20177         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20178                 if esep {
20179                         dd.ReadMapElemKey()
20180                 }
20181                 mk = nil
20182                 d.decode(&mk)
20183                 if bv, bok := mk.([]byte); bok {
20184                         mk = d.string(bv)
20185                 }
20186                 if esep {
20187                         dd.ReadMapElemValue()
20188                 }
20189                 if dd.TryDecodeAsNil() {
20190                         if v == nil {
20191                         } else if d.h.DeleteOnNilMapValue {
20192                                 delete(v, mk)
20193                         } else {
20194                                 v[mk] = 0
20195                         }
20196                         continue
20197                 }
20198                 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
20199                 if v != nil {
20200                         v[mk] = mv
20201                 }
20202         }
20203         dd.ReadMapEnd()
20204         d.depthDecr()
20205         return v, changed
20206 }
20207
20208 func (d *Decoder) fastpathDecMapIntfFloat64R(f *codecFnInfo, rv reflect.Value) {
20209         if rv.Kind() == reflect.Ptr {
20210                 vp := rv2i(rv).(*map[interface{}]float64)
20211                 v, changed := fastpathTV.DecMapIntfFloat64V(*vp, true, d)
20212                 if changed {
20213                         *vp = v
20214                 }
20215         } else {
20216                 fastpathTV.DecMapIntfFloat64V(rv2i(rv).(map[interface{}]float64), false, d)
20217         }
20218 }
20219 func (f fastpathT) DecMapIntfFloat64X(vp *map[interface{}]float64, d *Decoder) {
20220         v, changed := f.DecMapIntfFloat64V(*vp, true, d)
20221         if changed {
20222                 *vp = v
20223         }
20224 }
20225 func (_ fastpathT) DecMapIntfFloat64V(v map[interface{}]float64, canChange bool,
20226         d *Decoder) (_ map[interface{}]float64, changed bool) {
20227         dd, esep := d.d, d.hh.hasElemSeparators()
20228         containerLen := dd.ReadMapStart()
20229         if canChange && v == nil {
20230                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
20231                 v = make(map[interface{}]float64, xlen)
20232                 changed = true
20233         }
20234         if containerLen == 0 {
20235                 dd.ReadMapEnd()
20236                 return v, changed
20237         }
20238         d.depthIncr()
20239         var mk interface{}
20240         var mv float64
20241         hasLen := containerLen > 0
20242         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20243                 if esep {
20244                         dd.ReadMapElemKey()
20245                 }
20246                 mk = nil
20247                 d.decode(&mk)
20248                 if bv, bok := mk.([]byte); bok {
20249                         mk = d.string(bv)
20250                 }
20251                 if esep {
20252                         dd.ReadMapElemValue()
20253                 }
20254                 if dd.TryDecodeAsNil() {
20255                         if v == nil {
20256                         } else if d.h.DeleteOnNilMapValue {
20257                                 delete(v, mk)
20258                         } else {
20259                                 v[mk] = 0
20260                         }
20261                         continue
20262                 }
20263                 mv = dd.DecodeFloat64()
20264                 if v != nil {
20265                         v[mk] = mv
20266                 }
20267         }
20268         dd.ReadMapEnd()
20269         d.depthDecr()
20270         return v, changed
20271 }
20272
20273 func (d *Decoder) fastpathDecMapIntfBoolR(f *codecFnInfo, rv reflect.Value) {
20274         if rv.Kind() == reflect.Ptr {
20275                 vp := rv2i(rv).(*map[interface{}]bool)
20276                 v, changed := fastpathTV.DecMapIntfBoolV(*vp, true, d)
20277                 if changed {
20278                         *vp = v
20279                 }
20280         } else {
20281                 fastpathTV.DecMapIntfBoolV(rv2i(rv).(map[interface{}]bool), false, d)
20282         }
20283 }
20284 func (f fastpathT) DecMapIntfBoolX(vp *map[interface{}]bool, d *Decoder) {
20285         v, changed := f.DecMapIntfBoolV(*vp, true, d)
20286         if changed {
20287                 *vp = v
20288         }
20289 }
20290 func (_ fastpathT) DecMapIntfBoolV(v map[interface{}]bool, canChange bool,
20291         d *Decoder) (_ map[interface{}]bool, changed bool) {
20292         dd, esep := d.d, d.hh.hasElemSeparators()
20293         containerLen := dd.ReadMapStart()
20294         if canChange && v == nil {
20295                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
20296                 v = make(map[interface{}]bool, xlen)
20297                 changed = true
20298         }
20299         if containerLen == 0 {
20300                 dd.ReadMapEnd()
20301                 return v, changed
20302         }
20303         d.depthIncr()
20304         var mk interface{}
20305         var mv bool
20306         hasLen := containerLen > 0
20307         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20308                 if esep {
20309                         dd.ReadMapElemKey()
20310                 }
20311                 mk = nil
20312                 d.decode(&mk)
20313                 if bv, bok := mk.([]byte); bok {
20314                         mk = d.string(bv)
20315                 }
20316                 if esep {
20317                         dd.ReadMapElemValue()
20318                 }
20319                 if dd.TryDecodeAsNil() {
20320                         if v == nil {
20321                         } else if d.h.DeleteOnNilMapValue {
20322                                 delete(v, mk)
20323                         } else {
20324                                 v[mk] = false
20325                         }
20326                         continue
20327                 }
20328                 mv = dd.DecodeBool()
20329                 if v != nil {
20330                         v[mk] = mv
20331                 }
20332         }
20333         dd.ReadMapEnd()
20334         d.depthDecr()
20335         return v, changed
20336 }
20337
20338 func (d *Decoder) fastpathDecMapStringIntfR(f *codecFnInfo, rv reflect.Value) {
20339         if rv.Kind() == reflect.Ptr {
20340                 vp := rv2i(rv).(*map[string]interface{})
20341                 v, changed := fastpathTV.DecMapStringIntfV(*vp, true, d)
20342                 if changed {
20343                         *vp = v
20344                 }
20345         } else {
20346                 fastpathTV.DecMapStringIntfV(rv2i(rv).(map[string]interface{}), false, d)
20347         }
20348 }
20349 func (f fastpathT) DecMapStringIntfX(vp *map[string]interface{}, d *Decoder) {
20350         v, changed := f.DecMapStringIntfV(*vp, true, d)
20351         if changed {
20352                 *vp = v
20353         }
20354 }
20355 func (_ fastpathT) DecMapStringIntfV(v map[string]interface{}, canChange bool,
20356         d *Decoder) (_ map[string]interface{}, changed bool) {
20357         dd, esep := d.d, d.hh.hasElemSeparators()
20358         containerLen := dd.ReadMapStart()
20359         if canChange && v == nil {
20360                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 32)
20361                 v = make(map[string]interface{}, xlen)
20362                 changed = true
20363         }
20364         if containerLen == 0 {
20365                 dd.ReadMapEnd()
20366                 return v, changed
20367         }
20368         d.depthIncr()
20369         mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
20370         var mk string
20371         var mv interface{}
20372         hasLen := containerLen > 0
20373         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20374                 if esep {
20375                         dd.ReadMapElemKey()
20376                 }
20377                 mk = dd.DecodeString()
20378                 if esep {
20379                         dd.ReadMapElemValue()
20380                 }
20381                 if dd.TryDecodeAsNil() {
20382                         if v == nil {
20383                         } else if d.h.DeleteOnNilMapValue {
20384                                 delete(v, mk)
20385                         } else {
20386                                 v[mk] = nil
20387                         }
20388                         continue
20389                 }
20390                 if mapGet {
20391                         mv = v[mk]
20392                 } else {
20393                         mv = nil
20394                 }
20395                 d.decode(&mv)
20396                 if v != nil {
20397                         v[mk] = mv
20398                 }
20399         }
20400         dd.ReadMapEnd()
20401         d.depthDecr()
20402         return v, changed
20403 }
20404
20405 func (d *Decoder) fastpathDecMapStringStringR(f *codecFnInfo, rv reflect.Value) {
20406         if rv.Kind() == reflect.Ptr {
20407                 vp := rv2i(rv).(*map[string]string)
20408                 v, changed := fastpathTV.DecMapStringStringV(*vp, true, d)
20409                 if changed {
20410                         *vp = v
20411                 }
20412         } else {
20413                 fastpathTV.DecMapStringStringV(rv2i(rv).(map[string]string), false, d)
20414         }
20415 }
20416 func (f fastpathT) DecMapStringStringX(vp *map[string]string, d *Decoder) {
20417         v, changed := f.DecMapStringStringV(*vp, true, d)
20418         if changed {
20419                 *vp = v
20420         }
20421 }
20422 func (_ fastpathT) DecMapStringStringV(v map[string]string, canChange bool,
20423         d *Decoder) (_ map[string]string, changed bool) {
20424         dd, esep := d.d, d.hh.hasElemSeparators()
20425         containerLen := dd.ReadMapStart()
20426         if canChange && v == nil {
20427                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 32)
20428                 v = make(map[string]string, xlen)
20429                 changed = true
20430         }
20431         if containerLen == 0 {
20432                 dd.ReadMapEnd()
20433                 return v, changed
20434         }
20435         d.depthIncr()
20436         var mk string
20437         var mv string
20438         hasLen := containerLen > 0
20439         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20440                 if esep {
20441                         dd.ReadMapElemKey()
20442                 }
20443                 mk = dd.DecodeString()
20444                 if esep {
20445                         dd.ReadMapElemValue()
20446                 }
20447                 if dd.TryDecodeAsNil() {
20448                         if v == nil {
20449                         } else if d.h.DeleteOnNilMapValue {
20450                                 delete(v, mk)
20451                         } else {
20452                                 v[mk] = ""
20453                         }
20454                         continue
20455                 }
20456                 mv = dd.DecodeString()
20457                 if v != nil {
20458                         v[mk] = mv
20459                 }
20460         }
20461         dd.ReadMapEnd()
20462         d.depthDecr()
20463         return v, changed
20464 }
20465
20466 func (d *Decoder) fastpathDecMapStringUintR(f *codecFnInfo, rv reflect.Value) {
20467         if rv.Kind() == reflect.Ptr {
20468                 vp := rv2i(rv).(*map[string]uint)
20469                 v, changed := fastpathTV.DecMapStringUintV(*vp, true, d)
20470                 if changed {
20471                         *vp = v
20472                 }
20473         } else {
20474                 fastpathTV.DecMapStringUintV(rv2i(rv).(map[string]uint), false, d)
20475         }
20476 }
20477 func (f fastpathT) DecMapStringUintX(vp *map[string]uint, d *Decoder) {
20478         v, changed := f.DecMapStringUintV(*vp, true, d)
20479         if changed {
20480                 *vp = v
20481         }
20482 }
20483 func (_ fastpathT) DecMapStringUintV(v map[string]uint, canChange bool,
20484         d *Decoder) (_ map[string]uint, changed bool) {
20485         dd, esep := d.d, d.hh.hasElemSeparators()
20486         containerLen := dd.ReadMapStart()
20487         if canChange && v == nil {
20488                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
20489                 v = make(map[string]uint, xlen)
20490                 changed = true
20491         }
20492         if containerLen == 0 {
20493                 dd.ReadMapEnd()
20494                 return v, changed
20495         }
20496         d.depthIncr()
20497         var mk string
20498         var mv uint
20499         hasLen := containerLen > 0
20500         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20501                 if esep {
20502                         dd.ReadMapElemKey()
20503                 }
20504                 mk = dd.DecodeString()
20505                 if esep {
20506                         dd.ReadMapElemValue()
20507                 }
20508                 if dd.TryDecodeAsNil() {
20509                         if v == nil {
20510                         } else if d.h.DeleteOnNilMapValue {
20511                                 delete(v, mk)
20512                         } else {
20513                                 v[mk] = 0
20514                         }
20515                         continue
20516                 }
20517                 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
20518                 if v != nil {
20519                         v[mk] = mv
20520                 }
20521         }
20522         dd.ReadMapEnd()
20523         d.depthDecr()
20524         return v, changed
20525 }
20526
20527 func (d *Decoder) fastpathDecMapStringUint8R(f *codecFnInfo, rv reflect.Value) {
20528         if rv.Kind() == reflect.Ptr {
20529                 vp := rv2i(rv).(*map[string]uint8)
20530                 v, changed := fastpathTV.DecMapStringUint8V(*vp, true, d)
20531                 if changed {
20532                         *vp = v
20533                 }
20534         } else {
20535                 fastpathTV.DecMapStringUint8V(rv2i(rv).(map[string]uint8), false, d)
20536         }
20537 }
20538 func (f fastpathT) DecMapStringUint8X(vp *map[string]uint8, d *Decoder) {
20539         v, changed := f.DecMapStringUint8V(*vp, true, d)
20540         if changed {
20541                 *vp = v
20542         }
20543 }
20544 func (_ fastpathT) DecMapStringUint8V(v map[string]uint8, canChange bool,
20545         d *Decoder) (_ map[string]uint8, changed bool) {
20546         dd, esep := d.d, d.hh.hasElemSeparators()
20547         containerLen := dd.ReadMapStart()
20548         if canChange && v == nil {
20549                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
20550                 v = make(map[string]uint8, xlen)
20551                 changed = true
20552         }
20553         if containerLen == 0 {
20554                 dd.ReadMapEnd()
20555                 return v, changed
20556         }
20557         d.depthIncr()
20558         var mk string
20559         var mv uint8
20560         hasLen := containerLen > 0
20561         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20562                 if esep {
20563                         dd.ReadMapElemKey()
20564                 }
20565                 mk = dd.DecodeString()
20566                 if esep {
20567                         dd.ReadMapElemValue()
20568                 }
20569                 if dd.TryDecodeAsNil() {
20570                         if v == nil {
20571                         } else if d.h.DeleteOnNilMapValue {
20572                                 delete(v, mk)
20573                         } else {
20574                                 v[mk] = 0
20575                         }
20576                         continue
20577                 }
20578                 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
20579                 if v != nil {
20580                         v[mk] = mv
20581                 }
20582         }
20583         dd.ReadMapEnd()
20584         d.depthDecr()
20585         return v, changed
20586 }
20587
20588 func (d *Decoder) fastpathDecMapStringUint16R(f *codecFnInfo, rv reflect.Value) {
20589         if rv.Kind() == reflect.Ptr {
20590                 vp := rv2i(rv).(*map[string]uint16)
20591                 v, changed := fastpathTV.DecMapStringUint16V(*vp, true, d)
20592                 if changed {
20593                         *vp = v
20594                 }
20595         } else {
20596                 fastpathTV.DecMapStringUint16V(rv2i(rv).(map[string]uint16), false, d)
20597         }
20598 }
20599 func (f fastpathT) DecMapStringUint16X(vp *map[string]uint16, d *Decoder) {
20600         v, changed := f.DecMapStringUint16V(*vp, true, d)
20601         if changed {
20602                 *vp = v
20603         }
20604 }
20605 func (_ fastpathT) DecMapStringUint16V(v map[string]uint16, canChange bool,
20606         d *Decoder) (_ map[string]uint16, changed bool) {
20607         dd, esep := d.d, d.hh.hasElemSeparators()
20608         containerLen := dd.ReadMapStart()
20609         if canChange && v == nil {
20610                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
20611                 v = make(map[string]uint16, xlen)
20612                 changed = true
20613         }
20614         if containerLen == 0 {
20615                 dd.ReadMapEnd()
20616                 return v, changed
20617         }
20618         d.depthIncr()
20619         var mk string
20620         var mv uint16
20621         hasLen := containerLen > 0
20622         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20623                 if esep {
20624                         dd.ReadMapElemKey()
20625                 }
20626                 mk = dd.DecodeString()
20627                 if esep {
20628                         dd.ReadMapElemValue()
20629                 }
20630                 if dd.TryDecodeAsNil() {
20631                         if v == nil {
20632                         } else if d.h.DeleteOnNilMapValue {
20633                                 delete(v, mk)
20634                         } else {
20635                                 v[mk] = 0
20636                         }
20637                         continue
20638                 }
20639                 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
20640                 if v != nil {
20641                         v[mk] = mv
20642                 }
20643         }
20644         dd.ReadMapEnd()
20645         d.depthDecr()
20646         return v, changed
20647 }
20648
20649 func (d *Decoder) fastpathDecMapStringUint32R(f *codecFnInfo, rv reflect.Value) {
20650         if rv.Kind() == reflect.Ptr {
20651                 vp := rv2i(rv).(*map[string]uint32)
20652                 v, changed := fastpathTV.DecMapStringUint32V(*vp, true, d)
20653                 if changed {
20654                         *vp = v
20655                 }
20656         } else {
20657                 fastpathTV.DecMapStringUint32V(rv2i(rv).(map[string]uint32), false, d)
20658         }
20659 }
20660 func (f fastpathT) DecMapStringUint32X(vp *map[string]uint32, d *Decoder) {
20661         v, changed := f.DecMapStringUint32V(*vp, true, d)
20662         if changed {
20663                 *vp = v
20664         }
20665 }
20666 func (_ fastpathT) DecMapStringUint32V(v map[string]uint32, canChange bool,
20667         d *Decoder) (_ map[string]uint32, changed bool) {
20668         dd, esep := d.d, d.hh.hasElemSeparators()
20669         containerLen := dd.ReadMapStart()
20670         if canChange && v == nil {
20671                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
20672                 v = make(map[string]uint32, xlen)
20673                 changed = true
20674         }
20675         if containerLen == 0 {
20676                 dd.ReadMapEnd()
20677                 return v, changed
20678         }
20679         d.depthIncr()
20680         var mk string
20681         var mv uint32
20682         hasLen := containerLen > 0
20683         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20684                 if esep {
20685                         dd.ReadMapElemKey()
20686                 }
20687                 mk = dd.DecodeString()
20688                 if esep {
20689                         dd.ReadMapElemValue()
20690                 }
20691                 if dd.TryDecodeAsNil() {
20692                         if v == nil {
20693                         } else if d.h.DeleteOnNilMapValue {
20694                                 delete(v, mk)
20695                         } else {
20696                                 v[mk] = 0
20697                         }
20698                         continue
20699                 }
20700                 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
20701                 if v != nil {
20702                         v[mk] = mv
20703                 }
20704         }
20705         dd.ReadMapEnd()
20706         d.depthDecr()
20707         return v, changed
20708 }
20709
20710 func (d *Decoder) fastpathDecMapStringUint64R(f *codecFnInfo, rv reflect.Value) {
20711         if rv.Kind() == reflect.Ptr {
20712                 vp := rv2i(rv).(*map[string]uint64)
20713                 v, changed := fastpathTV.DecMapStringUint64V(*vp, true, d)
20714                 if changed {
20715                         *vp = v
20716                 }
20717         } else {
20718                 fastpathTV.DecMapStringUint64V(rv2i(rv).(map[string]uint64), false, d)
20719         }
20720 }
20721 func (f fastpathT) DecMapStringUint64X(vp *map[string]uint64, d *Decoder) {
20722         v, changed := f.DecMapStringUint64V(*vp, true, d)
20723         if changed {
20724                 *vp = v
20725         }
20726 }
20727 func (_ fastpathT) DecMapStringUint64V(v map[string]uint64, canChange bool,
20728         d *Decoder) (_ map[string]uint64, changed bool) {
20729         dd, esep := d.d, d.hh.hasElemSeparators()
20730         containerLen := dd.ReadMapStart()
20731         if canChange && v == nil {
20732                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
20733                 v = make(map[string]uint64, xlen)
20734                 changed = true
20735         }
20736         if containerLen == 0 {
20737                 dd.ReadMapEnd()
20738                 return v, changed
20739         }
20740         d.depthIncr()
20741         var mk string
20742         var mv uint64
20743         hasLen := containerLen > 0
20744         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20745                 if esep {
20746                         dd.ReadMapElemKey()
20747                 }
20748                 mk = dd.DecodeString()
20749                 if esep {
20750                         dd.ReadMapElemValue()
20751                 }
20752                 if dd.TryDecodeAsNil() {
20753                         if v == nil {
20754                         } else if d.h.DeleteOnNilMapValue {
20755                                 delete(v, mk)
20756                         } else {
20757                                 v[mk] = 0
20758                         }
20759                         continue
20760                 }
20761                 mv = dd.DecodeUint64()
20762                 if v != nil {
20763                         v[mk] = mv
20764                 }
20765         }
20766         dd.ReadMapEnd()
20767         d.depthDecr()
20768         return v, changed
20769 }
20770
20771 func (d *Decoder) fastpathDecMapStringUintptrR(f *codecFnInfo, rv reflect.Value) {
20772         if rv.Kind() == reflect.Ptr {
20773                 vp := rv2i(rv).(*map[string]uintptr)
20774                 v, changed := fastpathTV.DecMapStringUintptrV(*vp, true, d)
20775                 if changed {
20776                         *vp = v
20777                 }
20778         } else {
20779                 fastpathTV.DecMapStringUintptrV(rv2i(rv).(map[string]uintptr), false, d)
20780         }
20781 }
20782 func (f fastpathT) DecMapStringUintptrX(vp *map[string]uintptr, d *Decoder) {
20783         v, changed := f.DecMapStringUintptrV(*vp, true, d)
20784         if changed {
20785                 *vp = v
20786         }
20787 }
20788 func (_ fastpathT) DecMapStringUintptrV(v map[string]uintptr, canChange bool,
20789         d *Decoder) (_ map[string]uintptr, changed bool) {
20790         dd, esep := d.d, d.hh.hasElemSeparators()
20791         containerLen := dd.ReadMapStart()
20792         if canChange && v == nil {
20793                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
20794                 v = make(map[string]uintptr, xlen)
20795                 changed = true
20796         }
20797         if containerLen == 0 {
20798                 dd.ReadMapEnd()
20799                 return v, changed
20800         }
20801         d.depthIncr()
20802         var mk string
20803         var mv uintptr
20804         hasLen := containerLen > 0
20805         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20806                 if esep {
20807                         dd.ReadMapElemKey()
20808                 }
20809                 mk = dd.DecodeString()
20810                 if esep {
20811                         dd.ReadMapElemValue()
20812                 }
20813                 if dd.TryDecodeAsNil() {
20814                         if v == nil {
20815                         } else if d.h.DeleteOnNilMapValue {
20816                                 delete(v, mk)
20817                         } else {
20818                                 v[mk] = 0
20819                         }
20820                         continue
20821                 }
20822                 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
20823                 if v != nil {
20824                         v[mk] = mv
20825                 }
20826         }
20827         dd.ReadMapEnd()
20828         d.depthDecr()
20829         return v, changed
20830 }
20831
20832 func (d *Decoder) fastpathDecMapStringIntR(f *codecFnInfo, rv reflect.Value) {
20833         if rv.Kind() == reflect.Ptr {
20834                 vp := rv2i(rv).(*map[string]int)
20835                 v, changed := fastpathTV.DecMapStringIntV(*vp, true, d)
20836                 if changed {
20837                         *vp = v
20838                 }
20839         } else {
20840                 fastpathTV.DecMapStringIntV(rv2i(rv).(map[string]int), false, d)
20841         }
20842 }
20843 func (f fastpathT) DecMapStringIntX(vp *map[string]int, d *Decoder) {
20844         v, changed := f.DecMapStringIntV(*vp, true, d)
20845         if changed {
20846                 *vp = v
20847         }
20848 }
20849 func (_ fastpathT) DecMapStringIntV(v map[string]int, canChange bool,
20850         d *Decoder) (_ map[string]int, changed bool) {
20851         dd, esep := d.d, d.hh.hasElemSeparators()
20852         containerLen := dd.ReadMapStart()
20853         if canChange && v == nil {
20854                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
20855                 v = make(map[string]int, xlen)
20856                 changed = true
20857         }
20858         if containerLen == 0 {
20859                 dd.ReadMapEnd()
20860                 return v, changed
20861         }
20862         d.depthIncr()
20863         var mk string
20864         var mv int
20865         hasLen := containerLen > 0
20866         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20867                 if esep {
20868                         dd.ReadMapElemKey()
20869                 }
20870                 mk = dd.DecodeString()
20871                 if esep {
20872                         dd.ReadMapElemValue()
20873                 }
20874                 if dd.TryDecodeAsNil() {
20875                         if v == nil {
20876                         } else if d.h.DeleteOnNilMapValue {
20877                                 delete(v, mk)
20878                         } else {
20879                                 v[mk] = 0
20880                         }
20881                         continue
20882                 }
20883                 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
20884                 if v != nil {
20885                         v[mk] = mv
20886                 }
20887         }
20888         dd.ReadMapEnd()
20889         d.depthDecr()
20890         return v, changed
20891 }
20892
20893 func (d *Decoder) fastpathDecMapStringInt8R(f *codecFnInfo, rv reflect.Value) {
20894         if rv.Kind() == reflect.Ptr {
20895                 vp := rv2i(rv).(*map[string]int8)
20896                 v, changed := fastpathTV.DecMapStringInt8V(*vp, true, d)
20897                 if changed {
20898                         *vp = v
20899                 }
20900         } else {
20901                 fastpathTV.DecMapStringInt8V(rv2i(rv).(map[string]int8), false, d)
20902         }
20903 }
20904 func (f fastpathT) DecMapStringInt8X(vp *map[string]int8, d *Decoder) {
20905         v, changed := f.DecMapStringInt8V(*vp, true, d)
20906         if changed {
20907                 *vp = v
20908         }
20909 }
20910 func (_ fastpathT) DecMapStringInt8V(v map[string]int8, canChange bool,
20911         d *Decoder) (_ map[string]int8, changed bool) {
20912         dd, esep := d.d, d.hh.hasElemSeparators()
20913         containerLen := dd.ReadMapStart()
20914         if canChange && v == nil {
20915                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
20916                 v = make(map[string]int8, xlen)
20917                 changed = true
20918         }
20919         if containerLen == 0 {
20920                 dd.ReadMapEnd()
20921                 return v, changed
20922         }
20923         d.depthIncr()
20924         var mk string
20925         var mv int8
20926         hasLen := containerLen > 0
20927         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20928                 if esep {
20929                         dd.ReadMapElemKey()
20930                 }
20931                 mk = dd.DecodeString()
20932                 if esep {
20933                         dd.ReadMapElemValue()
20934                 }
20935                 if dd.TryDecodeAsNil() {
20936                         if v == nil {
20937                         } else if d.h.DeleteOnNilMapValue {
20938                                 delete(v, mk)
20939                         } else {
20940                                 v[mk] = 0
20941                         }
20942                         continue
20943                 }
20944                 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
20945                 if v != nil {
20946                         v[mk] = mv
20947                 }
20948         }
20949         dd.ReadMapEnd()
20950         d.depthDecr()
20951         return v, changed
20952 }
20953
20954 func (d *Decoder) fastpathDecMapStringInt16R(f *codecFnInfo, rv reflect.Value) {
20955         if rv.Kind() == reflect.Ptr {
20956                 vp := rv2i(rv).(*map[string]int16)
20957                 v, changed := fastpathTV.DecMapStringInt16V(*vp, true, d)
20958                 if changed {
20959                         *vp = v
20960                 }
20961         } else {
20962                 fastpathTV.DecMapStringInt16V(rv2i(rv).(map[string]int16), false, d)
20963         }
20964 }
20965 func (f fastpathT) DecMapStringInt16X(vp *map[string]int16, d *Decoder) {
20966         v, changed := f.DecMapStringInt16V(*vp, true, d)
20967         if changed {
20968                 *vp = v
20969         }
20970 }
20971 func (_ fastpathT) DecMapStringInt16V(v map[string]int16, canChange bool,
20972         d *Decoder) (_ map[string]int16, changed bool) {
20973         dd, esep := d.d, d.hh.hasElemSeparators()
20974         containerLen := dd.ReadMapStart()
20975         if canChange && v == nil {
20976                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
20977                 v = make(map[string]int16, xlen)
20978                 changed = true
20979         }
20980         if containerLen == 0 {
20981                 dd.ReadMapEnd()
20982                 return v, changed
20983         }
20984         d.depthIncr()
20985         var mk string
20986         var mv int16
20987         hasLen := containerLen > 0
20988         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20989                 if esep {
20990                         dd.ReadMapElemKey()
20991                 }
20992                 mk = dd.DecodeString()
20993                 if esep {
20994                         dd.ReadMapElemValue()
20995                 }
20996                 if dd.TryDecodeAsNil() {
20997                         if v == nil {
20998                         } else if d.h.DeleteOnNilMapValue {
20999                                 delete(v, mk)
21000                         } else {
21001                                 v[mk] = 0
21002                         }
21003                         continue
21004                 }
21005                 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
21006                 if v != nil {
21007                         v[mk] = mv
21008                 }
21009         }
21010         dd.ReadMapEnd()
21011         d.depthDecr()
21012         return v, changed
21013 }
21014
21015 func (d *Decoder) fastpathDecMapStringInt32R(f *codecFnInfo, rv reflect.Value) {
21016         if rv.Kind() == reflect.Ptr {
21017                 vp := rv2i(rv).(*map[string]int32)
21018                 v, changed := fastpathTV.DecMapStringInt32V(*vp, true, d)
21019                 if changed {
21020                         *vp = v
21021                 }
21022         } else {
21023                 fastpathTV.DecMapStringInt32V(rv2i(rv).(map[string]int32), false, d)
21024         }
21025 }
21026 func (f fastpathT) DecMapStringInt32X(vp *map[string]int32, d *Decoder) {
21027         v, changed := f.DecMapStringInt32V(*vp, true, d)
21028         if changed {
21029                 *vp = v
21030         }
21031 }
21032 func (_ fastpathT) DecMapStringInt32V(v map[string]int32, canChange bool,
21033         d *Decoder) (_ map[string]int32, changed bool) {
21034         dd, esep := d.d, d.hh.hasElemSeparators()
21035         containerLen := dd.ReadMapStart()
21036         if canChange && v == nil {
21037                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
21038                 v = make(map[string]int32, xlen)
21039                 changed = true
21040         }
21041         if containerLen == 0 {
21042                 dd.ReadMapEnd()
21043                 return v, changed
21044         }
21045         d.depthIncr()
21046         var mk string
21047         var mv int32
21048         hasLen := containerLen > 0
21049         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21050                 if esep {
21051                         dd.ReadMapElemKey()
21052                 }
21053                 mk = dd.DecodeString()
21054                 if esep {
21055                         dd.ReadMapElemValue()
21056                 }
21057                 if dd.TryDecodeAsNil() {
21058                         if v == nil {
21059                         } else if d.h.DeleteOnNilMapValue {
21060                                 delete(v, mk)
21061                         } else {
21062                                 v[mk] = 0
21063                         }
21064                         continue
21065                 }
21066                 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
21067                 if v != nil {
21068                         v[mk] = mv
21069                 }
21070         }
21071         dd.ReadMapEnd()
21072         d.depthDecr()
21073         return v, changed
21074 }
21075
21076 func (d *Decoder) fastpathDecMapStringInt64R(f *codecFnInfo, rv reflect.Value) {
21077         if rv.Kind() == reflect.Ptr {
21078                 vp := rv2i(rv).(*map[string]int64)
21079                 v, changed := fastpathTV.DecMapStringInt64V(*vp, true, d)
21080                 if changed {
21081                         *vp = v
21082                 }
21083         } else {
21084                 fastpathTV.DecMapStringInt64V(rv2i(rv).(map[string]int64), false, d)
21085         }
21086 }
21087 func (f fastpathT) DecMapStringInt64X(vp *map[string]int64, d *Decoder) {
21088         v, changed := f.DecMapStringInt64V(*vp, true, d)
21089         if changed {
21090                 *vp = v
21091         }
21092 }
21093 func (_ fastpathT) DecMapStringInt64V(v map[string]int64, canChange bool,
21094         d *Decoder) (_ map[string]int64, changed bool) {
21095         dd, esep := d.d, d.hh.hasElemSeparators()
21096         containerLen := dd.ReadMapStart()
21097         if canChange && v == nil {
21098                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
21099                 v = make(map[string]int64, xlen)
21100                 changed = true
21101         }
21102         if containerLen == 0 {
21103                 dd.ReadMapEnd()
21104                 return v, changed
21105         }
21106         d.depthIncr()
21107         var mk string
21108         var mv int64
21109         hasLen := containerLen > 0
21110         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21111                 if esep {
21112                         dd.ReadMapElemKey()
21113                 }
21114                 mk = dd.DecodeString()
21115                 if esep {
21116                         dd.ReadMapElemValue()
21117                 }
21118                 if dd.TryDecodeAsNil() {
21119                         if v == nil {
21120                         } else if d.h.DeleteOnNilMapValue {
21121                                 delete(v, mk)
21122                         } else {
21123                                 v[mk] = 0
21124                         }
21125                         continue
21126                 }
21127                 mv = dd.DecodeInt64()
21128                 if v != nil {
21129                         v[mk] = mv
21130                 }
21131         }
21132         dd.ReadMapEnd()
21133         d.depthDecr()
21134         return v, changed
21135 }
21136
21137 func (d *Decoder) fastpathDecMapStringFloat32R(f *codecFnInfo, rv reflect.Value) {
21138         if rv.Kind() == reflect.Ptr {
21139                 vp := rv2i(rv).(*map[string]float32)
21140                 v, changed := fastpathTV.DecMapStringFloat32V(*vp, true, d)
21141                 if changed {
21142                         *vp = v
21143                 }
21144         } else {
21145                 fastpathTV.DecMapStringFloat32V(rv2i(rv).(map[string]float32), false, d)
21146         }
21147 }
21148 func (f fastpathT) DecMapStringFloat32X(vp *map[string]float32, d *Decoder) {
21149         v, changed := f.DecMapStringFloat32V(*vp, true, d)
21150         if changed {
21151                 *vp = v
21152         }
21153 }
21154 func (_ fastpathT) DecMapStringFloat32V(v map[string]float32, canChange bool,
21155         d *Decoder) (_ map[string]float32, changed bool) {
21156         dd, esep := d.d, d.hh.hasElemSeparators()
21157         containerLen := dd.ReadMapStart()
21158         if canChange && v == nil {
21159                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
21160                 v = make(map[string]float32, xlen)
21161                 changed = true
21162         }
21163         if containerLen == 0 {
21164                 dd.ReadMapEnd()
21165                 return v, changed
21166         }
21167         d.depthIncr()
21168         var mk string
21169         var mv float32
21170         hasLen := containerLen > 0
21171         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21172                 if esep {
21173                         dd.ReadMapElemKey()
21174                 }
21175                 mk = dd.DecodeString()
21176                 if esep {
21177                         dd.ReadMapElemValue()
21178                 }
21179                 if dd.TryDecodeAsNil() {
21180                         if v == nil {
21181                         } else if d.h.DeleteOnNilMapValue {
21182                                 delete(v, mk)
21183                         } else {
21184                                 v[mk] = 0
21185                         }
21186                         continue
21187                 }
21188                 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21189                 if v != nil {
21190                         v[mk] = mv
21191                 }
21192         }
21193         dd.ReadMapEnd()
21194         d.depthDecr()
21195         return v, changed
21196 }
21197
21198 func (d *Decoder) fastpathDecMapStringFloat64R(f *codecFnInfo, rv reflect.Value) {
21199         if rv.Kind() == reflect.Ptr {
21200                 vp := rv2i(rv).(*map[string]float64)
21201                 v, changed := fastpathTV.DecMapStringFloat64V(*vp, true, d)
21202                 if changed {
21203                         *vp = v
21204                 }
21205         } else {
21206                 fastpathTV.DecMapStringFloat64V(rv2i(rv).(map[string]float64), false, d)
21207         }
21208 }
21209 func (f fastpathT) DecMapStringFloat64X(vp *map[string]float64, d *Decoder) {
21210         v, changed := f.DecMapStringFloat64V(*vp, true, d)
21211         if changed {
21212                 *vp = v
21213         }
21214 }
21215 func (_ fastpathT) DecMapStringFloat64V(v map[string]float64, canChange bool,
21216         d *Decoder) (_ map[string]float64, changed bool) {
21217         dd, esep := d.d, d.hh.hasElemSeparators()
21218         containerLen := dd.ReadMapStart()
21219         if canChange && v == nil {
21220                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
21221                 v = make(map[string]float64, xlen)
21222                 changed = true
21223         }
21224         if containerLen == 0 {
21225                 dd.ReadMapEnd()
21226                 return v, changed
21227         }
21228         d.depthIncr()
21229         var mk string
21230         var mv float64
21231         hasLen := containerLen > 0
21232         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21233                 if esep {
21234                         dd.ReadMapElemKey()
21235                 }
21236                 mk = dd.DecodeString()
21237                 if esep {
21238                         dd.ReadMapElemValue()
21239                 }
21240                 if dd.TryDecodeAsNil() {
21241                         if v == nil {
21242                         } else if d.h.DeleteOnNilMapValue {
21243                                 delete(v, mk)
21244                         } else {
21245                                 v[mk] = 0
21246                         }
21247                         continue
21248                 }
21249                 mv = dd.DecodeFloat64()
21250                 if v != nil {
21251                         v[mk] = mv
21252                 }
21253         }
21254         dd.ReadMapEnd()
21255         d.depthDecr()
21256         return v, changed
21257 }
21258
21259 func (d *Decoder) fastpathDecMapStringBoolR(f *codecFnInfo, rv reflect.Value) {
21260         if rv.Kind() == reflect.Ptr {
21261                 vp := rv2i(rv).(*map[string]bool)
21262                 v, changed := fastpathTV.DecMapStringBoolV(*vp, true, d)
21263                 if changed {
21264                         *vp = v
21265                 }
21266         } else {
21267                 fastpathTV.DecMapStringBoolV(rv2i(rv).(map[string]bool), false, d)
21268         }
21269 }
21270 func (f fastpathT) DecMapStringBoolX(vp *map[string]bool, d *Decoder) {
21271         v, changed := f.DecMapStringBoolV(*vp, true, d)
21272         if changed {
21273                 *vp = v
21274         }
21275 }
21276 func (_ fastpathT) DecMapStringBoolV(v map[string]bool, canChange bool,
21277         d *Decoder) (_ map[string]bool, changed bool) {
21278         dd, esep := d.d, d.hh.hasElemSeparators()
21279         containerLen := dd.ReadMapStart()
21280         if canChange && v == nil {
21281                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
21282                 v = make(map[string]bool, xlen)
21283                 changed = true
21284         }
21285         if containerLen == 0 {
21286                 dd.ReadMapEnd()
21287                 return v, changed
21288         }
21289         d.depthIncr()
21290         var mk string
21291         var mv bool
21292         hasLen := containerLen > 0
21293         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21294                 if esep {
21295                         dd.ReadMapElemKey()
21296                 }
21297                 mk = dd.DecodeString()
21298                 if esep {
21299                         dd.ReadMapElemValue()
21300                 }
21301                 if dd.TryDecodeAsNil() {
21302                         if v == nil {
21303                         } else if d.h.DeleteOnNilMapValue {
21304                                 delete(v, mk)
21305                         } else {
21306                                 v[mk] = false
21307                         }
21308                         continue
21309                 }
21310                 mv = dd.DecodeBool()
21311                 if v != nil {
21312                         v[mk] = mv
21313                 }
21314         }
21315         dd.ReadMapEnd()
21316         d.depthDecr()
21317         return v, changed
21318 }
21319
21320 func (d *Decoder) fastpathDecMapFloat32IntfR(f *codecFnInfo, rv reflect.Value) {
21321         if rv.Kind() == reflect.Ptr {
21322                 vp := rv2i(rv).(*map[float32]interface{})
21323                 v, changed := fastpathTV.DecMapFloat32IntfV(*vp, true, d)
21324                 if changed {
21325                         *vp = v
21326                 }
21327         } else {
21328                 fastpathTV.DecMapFloat32IntfV(rv2i(rv).(map[float32]interface{}), false, d)
21329         }
21330 }
21331 func (f fastpathT) DecMapFloat32IntfX(vp *map[float32]interface{}, d *Decoder) {
21332         v, changed := f.DecMapFloat32IntfV(*vp, true, d)
21333         if changed {
21334                 *vp = v
21335         }
21336 }
21337 func (_ fastpathT) DecMapFloat32IntfV(v map[float32]interface{}, canChange bool,
21338         d *Decoder) (_ map[float32]interface{}, changed bool) {
21339         dd, esep := d.d, d.hh.hasElemSeparators()
21340         containerLen := dd.ReadMapStart()
21341         if canChange && v == nil {
21342                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
21343                 v = make(map[float32]interface{}, xlen)
21344                 changed = true
21345         }
21346         if containerLen == 0 {
21347                 dd.ReadMapEnd()
21348                 return v, changed
21349         }
21350         d.depthIncr()
21351         mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
21352         var mk float32
21353         var mv interface{}
21354         hasLen := containerLen > 0
21355         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21356                 if esep {
21357                         dd.ReadMapElemKey()
21358                 }
21359                 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21360                 if esep {
21361                         dd.ReadMapElemValue()
21362                 }
21363                 if dd.TryDecodeAsNil() {
21364                         if v == nil {
21365                         } else if d.h.DeleteOnNilMapValue {
21366                                 delete(v, mk)
21367                         } else {
21368                                 v[mk] = nil
21369                         }
21370                         continue
21371                 }
21372                 if mapGet {
21373                         mv = v[mk]
21374                 } else {
21375                         mv = nil
21376                 }
21377                 d.decode(&mv)
21378                 if v != nil {
21379                         v[mk] = mv
21380                 }
21381         }
21382         dd.ReadMapEnd()
21383         d.depthDecr()
21384         return v, changed
21385 }
21386
21387 func (d *Decoder) fastpathDecMapFloat32StringR(f *codecFnInfo, rv reflect.Value) {
21388         if rv.Kind() == reflect.Ptr {
21389                 vp := rv2i(rv).(*map[float32]string)
21390                 v, changed := fastpathTV.DecMapFloat32StringV(*vp, true, d)
21391                 if changed {
21392                         *vp = v
21393                 }
21394         } else {
21395                 fastpathTV.DecMapFloat32StringV(rv2i(rv).(map[float32]string), false, d)
21396         }
21397 }
21398 func (f fastpathT) DecMapFloat32StringX(vp *map[float32]string, d *Decoder) {
21399         v, changed := f.DecMapFloat32StringV(*vp, true, d)
21400         if changed {
21401                 *vp = v
21402         }
21403 }
21404 func (_ fastpathT) DecMapFloat32StringV(v map[float32]string, canChange bool,
21405         d *Decoder) (_ map[float32]string, changed bool) {
21406         dd, esep := d.d, d.hh.hasElemSeparators()
21407         containerLen := dd.ReadMapStart()
21408         if canChange && v == nil {
21409                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
21410                 v = make(map[float32]string, xlen)
21411                 changed = true
21412         }
21413         if containerLen == 0 {
21414                 dd.ReadMapEnd()
21415                 return v, changed
21416         }
21417         d.depthIncr()
21418         var mk float32
21419         var mv string
21420         hasLen := containerLen > 0
21421         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21422                 if esep {
21423                         dd.ReadMapElemKey()
21424                 }
21425                 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21426                 if esep {
21427                         dd.ReadMapElemValue()
21428                 }
21429                 if dd.TryDecodeAsNil() {
21430                         if v == nil {
21431                         } else if d.h.DeleteOnNilMapValue {
21432                                 delete(v, mk)
21433                         } else {
21434                                 v[mk] = ""
21435                         }
21436                         continue
21437                 }
21438                 mv = dd.DecodeString()
21439                 if v != nil {
21440                         v[mk] = mv
21441                 }
21442         }
21443         dd.ReadMapEnd()
21444         d.depthDecr()
21445         return v, changed
21446 }
21447
21448 func (d *Decoder) fastpathDecMapFloat32UintR(f *codecFnInfo, rv reflect.Value) {
21449         if rv.Kind() == reflect.Ptr {
21450                 vp := rv2i(rv).(*map[float32]uint)
21451                 v, changed := fastpathTV.DecMapFloat32UintV(*vp, true, d)
21452                 if changed {
21453                         *vp = v
21454                 }
21455         } else {
21456                 fastpathTV.DecMapFloat32UintV(rv2i(rv).(map[float32]uint), false, d)
21457         }
21458 }
21459 func (f fastpathT) DecMapFloat32UintX(vp *map[float32]uint, d *Decoder) {
21460         v, changed := f.DecMapFloat32UintV(*vp, true, d)
21461         if changed {
21462                 *vp = v
21463         }
21464 }
21465 func (_ fastpathT) DecMapFloat32UintV(v map[float32]uint, canChange bool,
21466         d *Decoder) (_ map[float32]uint, changed bool) {
21467         dd, esep := d.d, d.hh.hasElemSeparators()
21468         containerLen := dd.ReadMapStart()
21469         if canChange && v == nil {
21470                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
21471                 v = make(map[float32]uint, xlen)
21472                 changed = true
21473         }
21474         if containerLen == 0 {
21475                 dd.ReadMapEnd()
21476                 return v, changed
21477         }
21478         d.depthIncr()
21479         var mk float32
21480         var mv uint
21481         hasLen := containerLen > 0
21482         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21483                 if esep {
21484                         dd.ReadMapElemKey()
21485                 }
21486                 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21487                 if esep {
21488                         dd.ReadMapElemValue()
21489                 }
21490                 if dd.TryDecodeAsNil() {
21491                         if v == nil {
21492                         } else if d.h.DeleteOnNilMapValue {
21493                                 delete(v, mk)
21494                         } else {
21495                                 v[mk] = 0
21496                         }
21497                         continue
21498                 }
21499                 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
21500                 if v != nil {
21501                         v[mk] = mv
21502                 }
21503         }
21504         dd.ReadMapEnd()
21505         d.depthDecr()
21506         return v, changed
21507 }
21508
21509 func (d *Decoder) fastpathDecMapFloat32Uint8R(f *codecFnInfo, rv reflect.Value) {
21510         if rv.Kind() == reflect.Ptr {
21511                 vp := rv2i(rv).(*map[float32]uint8)
21512                 v, changed := fastpathTV.DecMapFloat32Uint8V(*vp, true, d)
21513                 if changed {
21514                         *vp = v
21515                 }
21516         } else {
21517                 fastpathTV.DecMapFloat32Uint8V(rv2i(rv).(map[float32]uint8), false, d)
21518         }
21519 }
21520 func (f fastpathT) DecMapFloat32Uint8X(vp *map[float32]uint8, d *Decoder) {
21521         v, changed := f.DecMapFloat32Uint8V(*vp, true, d)
21522         if changed {
21523                 *vp = v
21524         }
21525 }
21526 func (_ fastpathT) DecMapFloat32Uint8V(v map[float32]uint8, canChange bool,
21527         d *Decoder) (_ map[float32]uint8, changed bool) {
21528         dd, esep := d.d, d.hh.hasElemSeparators()
21529         containerLen := dd.ReadMapStart()
21530         if canChange && v == nil {
21531                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
21532                 v = make(map[float32]uint8, xlen)
21533                 changed = true
21534         }
21535         if containerLen == 0 {
21536                 dd.ReadMapEnd()
21537                 return v, changed
21538         }
21539         d.depthIncr()
21540         var mk float32
21541         var mv uint8
21542         hasLen := containerLen > 0
21543         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21544                 if esep {
21545                         dd.ReadMapElemKey()
21546                 }
21547                 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21548                 if esep {
21549                         dd.ReadMapElemValue()
21550                 }
21551                 if dd.TryDecodeAsNil() {
21552                         if v == nil {
21553                         } else if d.h.DeleteOnNilMapValue {
21554                                 delete(v, mk)
21555                         } else {
21556                                 v[mk] = 0
21557                         }
21558                         continue
21559                 }
21560                 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
21561                 if v != nil {
21562                         v[mk] = mv
21563                 }
21564         }
21565         dd.ReadMapEnd()
21566         d.depthDecr()
21567         return v, changed
21568 }
21569
21570 func (d *Decoder) fastpathDecMapFloat32Uint16R(f *codecFnInfo, rv reflect.Value) {
21571         if rv.Kind() == reflect.Ptr {
21572                 vp := rv2i(rv).(*map[float32]uint16)
21573                 v, changed := fastpathTV.DecMapFloat32Uint16V(*vp, true, d)
21574                 if changed {
21575                         *vp = v
21576                 }
21577         } else {
21578                 fastpathTV.DecMapFloat32Uint16V(rv2i(rv).(map[float32]uint16), false, d)
21579         }
21580 }
21581 func (f fastpathT) DecMapFloat32Uint16X(vp *map[float32]uint16, d *Decoder) {
21582         v, changed := f.DecMapFloat32Uint16V(*vp, true, d)
21583         if changed {
21584                 *vp = v
21585         }
21586 }
21587 func (_ fastpathT) DecMapFloat32Uint16V(v map[float32]uint16, canChange bool,
21588         d *Decoder) (_ map[float32]uint16, changed bool) {
21589         dd, esep := d.d, d.hh.hasElemSeparators()
21590         containerLen := dd.ReadMapStart()
21591         if canChange && v == nil {
21592                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
21593                 v = make(map[float32]uint16, xlen)
21594                 changed = true
21595         }
21596         if containerLen == 0 {
21597                 dd.ReadMapEnd()
21598                 return v, changed
21599         }
21600         d.depthIncr()
21601         var mk float32
21602         var mv uint16
21603         hasLen := containerLen > 0
21604         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21605                 if esep {
21606                         dd.ReadMapElemKey()
21607                 }
21608                 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21609                 if esep {
21610                         dd.ReadMapElemValue()
21611                 }
21612                 if dd.TryDecodeAsNil() {
21613                         if v == nil {
21614                         } else if d.h.DeleteOnNilMapValue {
21615                                 delete(v, mk)
21616                         } else {
21617                                 v[mk] = 0
21618                         }
21619                         continue
21620                 }
21621                 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
21622                 if v != nil {
21623                         v[mk] = mv
21624                 }
21625         }
21626         dd.ReadMapEnd()
21627         d.depthDecr()
21628         return v, changed
21629 }
21630
21631 func (d *Decoder) fastpathDecMapFloat32Uint32R(f *codecFnInfo, rv reflect.Value) {
21632         if rv.Kind() == reflect.Ptr {
21633                 vp := rv2i(rv).(*map[float32]uint32)
21634                 v, changed := fastpathTV.DecMapFloat32Uint32V(*vp, true, d)
21635                 if changed {
21636                         *vp = v
21637                 }
21638         } else {
21639                 fastpathTV.DecMapFloat32Uint32V(rv2i(rv).(map[float32]uint32), false, d)
21640         }
21641 }
21642 func (f fastpathT) DecMapFloat32Uint32X(vp *map[float32]uint32, d *Decoder) {
21643         v, changed := f.DecMapFloat32Uint32V(*vp, true, d)
21644         if changed {
21645                 *vp = v
21646         }
21647 }
21648 func (_ fastpathT) DecMapFloat32Uint32V(v map[float32]uint32, canChange bool,
21649         d *Decoder) (_ map[float32]uint32, changed bool) {
21650         dd, esep := d.d, d.hh.hasElemSeparators()
21651         containerLen := dd.ReadMapStart()
21652         if canChange && v == nil {
21653                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
21654                 v = make(map[float32]uint32, xlen)
21655                 changed = true
21656         }
21657         if containerLen == 0 {
21658                 dd.ReadMapEnd()
21659                 return v, changed
21660         }
21661         d.depthIncr()
21662         var mk float32
21663         var mv uint32
21664         hasLen := containerLen > 0
21665         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21666                 if esep {
21667                         dd.ReadMapElemKey()
21668                 }
21669                 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21670                 if esep {
21671                         dd.ReadMapElemValue()
21672                 }
21673                 if dd.TryDecodeAsNil() {
21674                         if v == nil {
21675                         } else if d.h.DeleteOnNilMapValue {
21676                                 delete(v, mk)
21677                         } else {
21678                                 v[mk] = 0
21679                         }
21680                         continue
21681                 }
21682                 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
21683                 if v != nil {
21684                         v[mk] = mv
21685                 }
21686         }
21687         dd.ReadMapEnd()
21688         d.depthDecr()
21689         return v, changed
21690 }
21691
21692 func (d *Decoder) fastpathDecMapFloat32Uint64R(f *codecFnInfo, rv reflect.Value) {
21693         if rv.Kind() == reflect.Ptr {
21694                 vp := rv2i(rv).(*map[float32]uint64)
21695                 v, changed := fastpathTV.DecMapFloat32Uint64V(*vp, true, d)
21696                 if changed {
21697                         *vp = v
21698                 }
21699         } else {
21700                 fastpathTV.DecMapFloat32Uint64V(rv2i(rv).(map[float32]uint64), false, d)
21701         }
21702 }
21703 func (f fastpathT) DecMapFloat32Uint64X(vp *map[float32]uint64, d *Decoder) {
21704         v, changed := f.DecMapFloat32Uint64V(*vp, true, d)
21705         if changed {
21706                 *vp = v
21707         }
21708 }
21709 func (_ fastpathT) DecMapFloat32Uint64V(v map[float32]uint64, canChange bool,
21710         d *Decoder) (_ map[float32]uint64, changed bool) {
21711         dd, esep := d.d, d.hh.hasElemSeparators()
21712         containerLen := dd.ReadMapStart()
21713         if canChange && v == nil {
21714                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
21715                 v = make(map[float32]uint64, xlen)
21716                 changed = true
21717         }
21718         if containerLen == 0 {
21719                 dd.ReadMapEnd()
21720                 return v, changed
21721         }
21722         d.depthIncr()
21723         var mk float32
21724         var mv uint64
21725         hasLen := containerLen > 0
21726         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21727                 if esep {
21728                         dd.ReadMapElemKey()
21729                 }
21730                 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21731                 if esep {
21732                         dd.ReadMapElemValue()
21733                 }
21734                 if dd.TryDecodeAsNil() {
21735                         if v == nil {
21736                         } else if d.h.DeleteOnNilMapValue {
21737                                 delete(v, mk)
21738                         } else {
21739                                 v[mk] = 0
21740                         }
21741                         continue
21742                 }
21743                 mv = dd.DecodeUint64()
21744                 if v != nil {
21745                         v[mk] = mv
21746                 }
21747         }
21748         dd.ReadMapEnd()
21749         d.depthDecr()
21750         return v, changed
21751 }
21752
21753 func (d *Decoder) fastpathDecMapFloat32UintptrR(f *codecFnInfo, rv reflect.Value) {
21754         if rv.Kind() == reflect.Ptr {
21755                 vp := rv2i(rv).(*map[float32]uintptr)
21756                 v, changed := fastpathTV.DecMapFloat32UintptrV(*vp, true, d)
21757                 if changed {
21758                         *vp = v
21759                 }
21760         } else {
21761                 fastpathTV.DecMapFloat32UintptrV(rv2i(rv).(map[float32]uintptr), false, d)
21762         }
21763 }
21764 func (f fastpathT) DecMapFloat32UintptrX(vp *map[float32]uintptr, d *Decoder) {
21765         v, changed := f.DecMapFloat32UintptrV(*vp, true, d)
21766         if changed {
21767                 *vp = v
21768         }
21769 }
21770 func (_ fastpathT) DecMapFloat32UintptrV(v map[float32]uintptr, canChange bool,
21771         d *Decoder) (_ map[float32]uintptr, changed bool) {
21772         dd, esep := d.d, d.hh.hasElemSeparators()
21773         containerLen := dd.ReadMapStart()
21774         if canChange && v == nil {
21775                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
21776                 v = make(map[float32]uintptr, xlen)
21777                 changed = true
21778         }
21779         if containerLen == 0 {
21780                 dd.ReadMapEnd()
21781                 return v, changed
21782         }
21783         d.depthIncr()
21784         var mk float32
21785         var mv uintptr
21786         hasLen := containerLen > 0
21787         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21788                 if esep {
21789                         dd.ReadMapElemKey()
21790                 }
21791                 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21792                 if esep {
21793                         dd.ReadMapElemValue()
21794                 }
21795                 if dd.TryDecodeAsNil() {
21796                         if v == nil {
21797                         } else if d.h.DeleteOnNilMapValue {
21798                                 delete(v, mk)
21799                         } else {
21800                                 v[mk] = 0
21801                         }
21802                         continue
21803                 }
21804                 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
21805                 if v != nil {
21806                         v[mk] = mv
21807                 }
21808         }
21809         dd.ReadMapEnd()
21810         d.depthDecr()
21811         return v, changed
21812 }
21813
21814 func (d *Decoder) fastpathDecMapFloat32IntR(f *codecFnInfo, rv reflect.Value) {
21815         if rv.Kind() == reflect.Ptr {
21816                 vp := rv2i(rv).(*map[float32]int)
21817                 v, changed := fastpathTV.DecMapFloat32IntV(*vp, true, d)
21818                 if changed {
21819                         *vp = v
21820                 }
21821         } else {
21822                 fastpathTV.DecMapFloat32IntV(rv2i(rv).(map[float32]int), false, d)
21823         }
21824 }
21825 func (f fastpathT) DecMapFloat32IntX(vp *map[float32]int, d *Decoder) {
21826         v, changed := f.DecMapFloat32IntV(*vp, true, d)
21827         if changed {
21828                 *vp = v
21829         }
21830 }
21831 func (_ fastpathT) DecMapFloat32IntV(v map[float32]int, canChange bool,
21832         d *Decoder) (_ map[float32]int, changed bool) {
21833         dd, esep := d.d, d.hh.hasElemSeparators()
21834         containerLen := dd.ReadMapStart()
21835         if canChange && v == nil {
21836                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
21837                 v = make(map[float32]int, xlen)
21838                 changed = true
21839         }
21840         if containerLen == 0 {
21841                 dd.ReadMapEnd()
21842                 return v, changed
21843         }
21844         d.depthIncr()
21845         var mk float32
21846         var mv int
21847         hasLen := containerLen > 0
21848         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21849                 if esep {
21850                         dd.ReadMapElemKey()
21851                 }
21852                 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21853                 if esep {
21854                         dd.ReadMapElemValue()
21855                 }
21856                 if dd.TryDecodeAsNil() {
21857                         if v == nil {
21858                         } else if d.h.DeleteOnNilMapValue {
21859                                 delete(v, mk)
21860                         } else {
21861                                 v[mk] = 0
21862                         }
21863                         continue
21864                 }
21865                 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
21866                 if v != nil {
21867                         v[mk] = mv
21868                 }
21869         }
21870         dd.ReadMapEnd()
21871         d.depthDecr()
21872         return v, changed
21873 }
21874
21875 func (d *Decoder) fastpathDecMapFloat32Int8R(f *codecFnInfo, rv reflect.Value) {
21876         if rv.Kind() == reflect.Ptr {
21877                 vp := rv2i(rv).(*map[float32]int8)
21878                 v, changed := fastpathTV.DecMapFloat32Int8V(*vp, true, d)
21879                 if changed {
21880                         *vp = v
21881                 }
21882         } else {
21883                 fastpathTV.DecMapFloat32Int8V(rv2i(rv).(map[float32]int8), false, d)
21884         }
21885 }
21886 func (f fastpathT) DecMapFloat32Int8X(vp *map[float32]int8, d *Decoder) {
21887         v, changed := f.DecMapFloat32Int8V(*vp, true, d)
21888         if changed {
21889                 *vp = v
21890         }
21891 }
21892 func (_ fastpathT) DecMapFloat32Int8V(v map[float32]int8, canChange bool,
21893         d *Decoder) (_ map[float32]int8, changed bool) {
21894         dd, esep := d.d, d.hh.hasElemSeparators()
21895         containerLen := dd.ReadMapStart()
21896         if canChange && v == nil {
21897                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
21898                 v = make(map[float32]int8, xlen)
21899                 changed = true
21900         }
21901         if containerLen == 0 {
21902                 dd.ReadMapEnd()
21903                 return v, changed
21904         }
21905         d.depthIncr()
21906         var mk float32
21907         var mv int8
21908         hasLen := containerLen > 0
21909         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21910                 if esep {
21911                         dd.ReadMapElemKey()
21912                 }
21913                 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21914                 if esep {
21915                         dd.ReadMapElemValue()
21916                 }
21917                 if dd.TryDecodeAsNil() {
21918                         if v == nil {
21919                         } else if d.h.DeleteOnNilMapValue {
21920                                 delete(v, mk)
21921                         } else {
21922                                 v[mk] = 0
21923                         }
21924                         continue
21925                 }
21926                 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
21927                 if v != nil {
21928                         v[mk] = mv
21929                 }
21930         }
21931         dd.ReadMapEnd()
21932         d.depthDecr()
21933         return v, changed
21934 }
21935
21936 func (d *Decoder) fastpathDecMapFloat32Int16R(f *codecFnInfo, rv reflect.Value) {
21937         if rv.Kind() == reflect.Ptr {
21938                 vp := rv2i(rv).(*map[float32]int16)
21939                 v, changed := fastpathTV.DecMapFloat32Int16V(*vp, true, d)
21940                 if changed {
21941                         *vp = v
21942                 }
21943         } else {
21944                 fastpathTV.DecMapFloat32Int16V(rv2i(rv).(map[float32]int16), false, d)
21945         }
21946 }
21947 func (f fastpathT) DecMapFloat32Int16X(vp *map[float32]int16, d *Decoder) {
21948         v, changed := f.DecMapFloat32Int16V(*vp, true, d)
21949         if changed {
21950                 *vp = v
21951         }
21952 }
21953 func (_ fastpathT) DecMapFloat32Int16V(v map[float32]int16, canChange bool,
21954         d *Decoder) (_ map[float32]int16, changed bool) {
21955         dd, esep := d.d, d.hh.hasElemSeparators()
21956         containerLen := dd.ReadMapStart()
21957         if canChange && v == nil {
21958                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
21959                 v = make(map[float32]int16, xlen)
21960                 changed = true
21961         }
21962         if containerLen == 0 {
21963                 dd.ReadMapEnd()
21964                 return v, changed
21965         }
21966         d.depthIncr()
21967         var mk float32
21968         var mv int16
21969         hasLen := containerLen > 0
21970         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21971                 if esep {
21972                         dd.ReadMapElemKey()
21973                 }
21974                 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21975                 if esep {
21976                         dd.ReadMapElemValue()
21977                 }
21978                 if dd.TryDecodeAsNil() {
21979                         if v == nil {
21980                         } else if d.h.DeleteOnNilMapValue {
21981                                 delete(v, mk)
21982                         } else {
21983                                 v[mk] = 0
21984                         }
21985                         continue
21986                 }
21987                 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
21988                 if v != nil {
21989                         v[mk] = mv
21990                 }
21991         }
21992         dd.ReadMapEnd()
21993         d.depthDecr()
21994         return v, changed
21995 }
21996
21997 func (d *Decoder) fastpathDecMapFloat32Int32R(f *codecFnInfo, rv reflect.Value) {
21998         if rv.Kind() == reflect.Ptr {
21999                 vp := rv2i(rv).(*map[float32]int32)
22000                 v, changed := fastpathTV.DecMapFloat32Int32V(*vp, true, d)
22001                 if changed {
22002                         *vp = v
22003                 }
22004         } else {
22005                 fastpathTV.DecMapFloat32Int32V(rv2i(rv).(map[float32]int32), false, d)
22006         }
22007 }
22008 func (f fastpathT) DecMapFloat32Int32X(vp *map[float32]int32, d *Decoder) {
22009         v, changed := f.DecMapFloat32Int32V(*vp, true, d)
22010         if changed {
22011                 *vp = v
22012         }
22013 }
22014 func (_ fastpathT) DecMapFloat32Int32V(v map[float32]int32, canChange bool,
22015         d *Decoder) (_ map[float32]int32, changed bool) {
22016         dd, esep := d.d, d.hh.hasElemSeparators()
22017         containerLen := dd.ReadMapStart()
22018         if canChange && v == nil {
22019                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
22020                 v = make(map[float32]int32, xlen)
22021                 changed = true
22022         }
22023         if containerLen == 0 {
22024                 dd.ReadMapEnd()
22025                 return v, changed
22026         }
22027         d.depthIncr()
22028         var mk float32
22029         var mv int32
22030         hasLen := containerLen > 0
22031         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22032                 if esep {
22033                         dd.ReadMapElemKey()
22034                 }
22035                 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
22036                 if esep {
22037                         dd.ReadMapElemValue()
22038                 }
22039                 if dd.TryDecodeAsNil() {
22040                         if v == nil {
22041                         } else if d.h.DeleteOnNilMapValue {
22042                                 delete(v, mk)
22043                         } else {
22044                                 v[mk] = 0
22045                         }
22046                         continue
22047                 }
22048                 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
22049                 if v != nil {
22050                         v[mk] = mv
22051                 }
22052         }
22053         dd.ReadMapEnd()
22054         d.depthDecr()
22055         return v, changed
22056 }
22057
22058 func (d *Decoder) fastpathDecMapFloat32Int64R(f *codecFnInfo, rv reflect.Value) {
22059         if rv.Kind() == reflect.Ptr {
22060                 vp := rv2i(rv).(*map[float32]int64)
22061                 v, changed := fastpathTV.DecMapFloat32Int64V(*vp, true, d)
22062                 if changed {
22063                         *vp = v
22064                 }
22065         } else {
22066                 fastpathTV.DecMapFloat32Int64V(rv2i(rv).(map[float32]int64), false, d)
22067         }
22068 }
22069 func (f fastpathT) DecMapFloat32Int64X(vp *map[float32]int64, d *Decoder) {
22070         v, changed := f.DecMapFloat32Int64V(*vp, true, d)
22071         if changed {
22072                 *vp = v
22073         }
22074 }
22075 func (_ fastpathT) DecMapFloat32Int64V(v map[float32]int64, canChange bool,
22076         d *Decoder) (_ map[float32]int64, changed bool) {
22077         dd, esep := d.d, d.hh.hasElemSeparators()
22078         containerLen := dd.ReadMapStart()
22079         if canChange && v == nil {
22080                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
22081                 v = make(map[float32]int64, xlen)
22082                 changed = true
22083         }
22084         if containerLen == 0 {
22085                 dd.ReadMapEnd()
22086                 return v, changed
22087         }
22088         d.depthIncr()
22089         var mk float32
22090         var mv int64
22091         hasLen := containerLen > 0
22092         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22093                 if esep {
22094                         dd.ReadMapElemKey()
22095                 }
22096                 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
22097                 if esep {
22098                         dd.ReadMapElemValue()
22099                 }
22100                 if dd.TryDecodeAsNil() {
22101                         if v == nil {
22102                         } else if d.h.DeleteOnNilMapValue {
22103                                 delete(v, mk)
22104                         } else {
22105                                 v[mk] = 0
22106                         }
22107                         continue
22108                 }
22109                 mv = dd.DecodeInt64()
22110                 if v != nil {
22111                         v[mk] = mv
22112                 }
22113         }
22114         dd.ReadMapEnd()
22115         d.depthDecr()
22116         return v, changed
22117 }
22118
22119 func (d *Decoder) fastpathDecMapFloat32Float32R(f *codecFnInfo, rv reflect.Value) {
22120         if rv.Kind() == reflect.Ptr {
22121                 vp := rv2i(rv).(*map[float32]float32)
22122                 v, changed := fastpathTV.DecMapFloat32Float32V(*vp, true, d)
22123                 if changed {
22124                         *vp = v
22125                 }
22126         } else {
22127                 fastpathTV.DecMapFloat32Float32V(rv2i(rv).(map[float32]float32), false, d)
22128         }
22129 }
22130 func (f fastpathT) DecMapFloat32Float32X(vp *map[float32]float32, d *Decoder) {
22131         v, changed := f.DecMapFloat32Float32V(*vp, true, d)
22132         if changed {
22133                 *vp = v
22134         }
22135 }
22136 func (_ fastpathT) DecMapFloat32Float32V(v map[float32]float32, canChange bool,
22137         d *Decoder) (_ map[float32]float32, changed bool) {
22138         dd, esep := d.d, d.hh.hasElemSeparators()
22139         containerLen := dd.ReadMapStart()
22140         if canChange && v == nil {
22141                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
22142                 v = make(map[float32]float32, xlen)
22143                 changed = true
22144         }
22145         if containerLen == 0 {
22146                 dd.ReadMapEnd()
22147                 return v, changed
22148         }
22149         d.depthIncr()
22150         var mk float32
22151         var mv float32
22152         hasLen := containerLen > 0
22153         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22154                 if esep {
22155                         dd.ReadMapElemKey()
22156                 }
22157                 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
22158                 if esep {
22159                         dd.ReadMapElemValue()
22160                 }
22161                 if dd.TryDecodeAsNil() {
22162                         if v == nil {
22163                         } else if d.h.DeleteOnNilMapValue {
22164                                 delete(v, mk)
22165                         } else {
22166                                 v[mk] = 0
22167                         }
22168                         continue
22169                 }
22170                 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
22171                 if v != nil {
22172                         v[mk] = mv
22173                 }
22174         }
22175         dd.ReadMapEnd()
22176         d.depthDecr()
22177         return v, changed
22178 }
22179
22180 func (d *Decoder) fastpathDecMapFloat32Float64R(f *codecFnInfo, rv reflect.Value) {
22181         if rv.Kind() == reflect.Ptr {
22182                 vp := rv2i(rv).(*map[float32]float64)
22183                 v, changed := fastpathTV.DecMapFloat32Float64V(*vp, true, d)
22184                 if changed {
22185                         *vp = v
22186                 }
22187         } else {
22188                 fastpathTV.DecMapFloat32Float64V(rv2i(rv).(map[float32]float64), false, d)
22189         }
22190 }
22191 func (f fastpathT) DecMapFloat32Float64X(vp *map[float32]float64, d *Decoder) {
22192         v, changed := f.DecMapFloat32Float64V(*vp, true, d)
22193         if changed {
22194                 *vp = v
22195         }
22196 }
22197 func (_ fastpathT) DecMapFloat32Float64V(v map[float32]float64, canChange bool,
22198         d *Decoder) (_ map[float32]float64, changed bool) {
22199         dd, esep := d.d, d.hh.hasElemSeparators()
22200         containerLen := dd.ReadMapStart()
22201         if canChange && v == nil {
22202                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
22203                 v = make(map[float32]float64, xlen)
22204                 changed = true
22205         }
22206         if containerLen == 0 {
22207                 dd.ReadMapEnd()
22208                 return v, changed
22209         }
22210         d.depthIncr()
22211         var mk float32
22212         var mv float64
22213         hasLen := containerLen > 0
22214         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22215                 if esep {
22216                         dd.ReadMapElemKey()
22217                 }
22218                 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
22219                 if esep {
22220                         dd.ReadMapElemValue()
22221                 }
22222                 if dd.TryDecodeAsNil() {
22223                         if v == nil {
22224                         } else if d.h.DeleteOnNilMapValue {
22225                                 delete(v, mk)
22226                         } else {
22227                                 v[mk] = 0
22228                         }
22229                         continue
22230                 }
22231                 mv = dd.DecodeFloat64()
22232                 if v != nil {
22233                         v[mk] = mv
22234                 }
22235         }
22236         dd.ReadMapEnd()
22237         d.depthDecr()
22238         return v, changed
22239 }
22240
22241 func (d *Decoder) fastpathDecMapFloat32BoolR(f *codecFnInfo, rv reflect.Value) {
22242         if rv.Kind() == reflect.Ptr {
22243                 vp := rv2i(rv).(*map[float32]bool)
22244                 v, changed := fastpathTV.DecMapFloat32BoolV(*vp, true, d)
22245                 if changed {
22246                         *vp = v
22247                 }
22248         } else {
22249                 fastpathTV.DecMapFloat32BoolV(rv2i(rv).(map[float32]bool), false, d)
22250         }
22251 }
22252 func (f fastpathT) DecMapFloat32BoolX(vp *map[float32]bool, d *Decoder) {
22253         v, changed := f.DecMapFloat32BoolV(*vp, true, d)
22254         if changed {
22255                 *vp = v
22256         }
22257 }
22258 func (_ fastpathT) DecMapFloat32BoolV(v map[float32]bool, canChange bool,
22259         d *Decoder) (_ map[float32]bool, changed bool) {
22260         dd, esep := d.d, d.hh.hasElemSeparators()
22261         containerLen := dd.ReadMapStart()
22262         if canChange && v == nil {
22263                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
22264                 v = make(map[float32]bool, xlen)
22265                 changed = true
22266         }
22267         if containerLen == 0 {
22268                 dd.ReadMapEnd()
22269                 return v, changed
22270         }
22271         d.depthIncr()
22272         var mk float32
22273         var mv bool
22274         hasLen := containerLen > 0
22275         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22276                 if esep {
22277                         dd.ReadMapElemKey()
22278                 }
22279                 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
22280                 if esep {
22281                         dd.ReadMapElemValue()
22282                 }
22283                 if dd.TryDecodeAsNil() {
22284                         if v == nil {
22285                         } else if d.h.DeleteOnNilMapValue {
22286                                 delete(v, mk)
22287                         } else {
22288                                 v[mk] = false
22289                         }
22290                         continue
22291                 }
22292                 mv = dd.DecodeBool()
22293                 if v != nil {
22294                         v[mk] = mv
22295                 }
22296         }
22297         dd.ReadMapEnd()
22298         d.depthDecr()
22299         return v, changed
22300 }
22301
22302 func (d *Decoder) fastpathDecMapFloat64IntfR(f *codecFnInfo, rv reflect.Value) {
22303         if rv.Kind() == reflect.Ptr {
22304                 vp := rv2i(rv).(*map[float64]interface{})
22305                 v, changed := fastpathTV.DecMapFloat64IntfV(*vp, true, d)
22306                 if changed {
22307                         *vp = v
22308                 }
22309         } else {
22310                 fastpathTV.DecMapFloat64IntfV(rv2i(rv).(map[float64]interface{}), false, d)
22311         }
22312 }
22313 func (f fastpathT) DecMapFloat64IntfX(vp *map[float64]interface{}, d *Decoder) {
22314         v, changed := f.DecMapFloat64IntfV(*vp, true, d)
22315         if changed {
22316                 *vp = v
22317         }
22318 }
22319 func (_ fastpathT) DecMapFloat64IntfV(v map[float64]interface{}, canChange bool,
22320         d *Decoder) (_ map[float64]interface{}, changed bool) {
22321         dd, esep := d.d, d.hh.hasElemSeparators()
22322         containerLen := dd.ReadMapStart()
22323         if canChange && v == nil {
22324                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
22325                 v = make(map[float64]interface{}, xlen)
22326                 changed = true
22327         }
22328         if containerLen == 0 {
22329                 dd.ReadMapEnd()
22330                 return v, changed
22331         }
22332         d.depthIncr()
22333         mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
22334         var mk float64
22335         var mv interface{}
22336         hasLen := containerLen > 0
22337         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22338                 if esep {
22339                         dd.ReadMapElemKey()
22340                 }
22341                 mk = dd.DecodeFloat64()
22342                 if esep {
22343                         dd.ReadMapElemValue()
22344                 }
22345                 if dd.TryDecodeAsNil() {
22346                         if v == nil {
22347                         } else if d.h.DeleteOnNilMapValue {
22348                                 delete(v, mk)
22349                         } else {
22350                                 v[mk] = nil
22351                         }
22352                         continue
22353                 }
22354                 if mapGet {
22355                         mv = v[mk]
22356                 } else {
22357                         mv = nil
22358                 }
22359                 d.decode(&mv)
22360                 if v != nil {
22361                         v[mk] = mv
22362                 }
22363         }
22364         dd.ReadMapEnd()
22365         d.depthDecr()
22366         return v, changed
22367 }
22368
22369 func (d *Decoder) fastpathDecMapFloat64StringR(f *codecFnInfo, rv reflect.Value) {
22370         if rv.Kind() == reflect.Ptr {
22371                 vp := rv2i(rv).(*map[float64]string)
22372                 v, changed := fastpathTV.DecMapFloat64StringV(*vp, true, d)
22373                 if changed {
22374                         *vp = v
22375                 }
22376         } else {
22377                 fastpathTV.DecMapFloat64StringV(rv2i(rv).(map[float64]string), false, d)
22378         }
22379 }
22380 func (f fastpathT) DecMapFloat64StringX(vp *map[float64]string, d *Decoder) {
22381         v, changed := f.DecMapFloat64StringV(*vp, true, d)
22382         if changed {
22383                 *vp = v
22384         }
22385 }
22386 func (_ fastpathT) DecMapFloat64StringV(v map[float64]string, canChange bool,
22387         d *Decoder) (_ map[float64]string, changed bool) {
22388         dd, esep := d.d, d.hh.hasElemSeparators()
22389         containerLen := dd.ReadMapStart()
22390         if canChange && v == nil {
22391                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
22392                 v = make(map[float64]string, xlen)
22393                 changed = true
22394         }
22395         if containerLen == 0 {
22396                 dd.ReadMapEnd()
22397                 return v, changed
22398         }
22399         d.depthIncr()
22400         var mk float64
22401         var mv string
22402         hasLen := containerLen > 0
22403         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22404                 if esep {
22405                         dd.ReadMapElemKey()
22406                 }
22407                 mk = dd.DecodeFloat64()
22408                 if esep {
22409                         dd.ReadMapElemValue()
22410                 }
22411                 if dd.TryDecodeAsNil() {
22412                         if v == nil {
22413                         } else if d.h.DeleteOnNilMapValue {
22414                                 delete(v, mk)
22415                         } else {
22416                                 v[mk] = ""
22417                         }
22418                         continue
22419                 }
22420                 mv = dd.DecodeString()
22421                 if v != nil {
22422                         v[mk] = mv
22423                 }
22424         }
22425         dd.ReadMapEnd()
22426         d.depthDecr()
22427         return v, changed
22428 }
22429
22430 func (d *Decoder) fastpathDecMapFloat64UintR(f *codecFnInfo, rv reflect.Value) {
22431         if rv.Kind() == reflect.Ptr {
22432                 vp := rv2i(rv).(*map[float64]uint)
22433                 v, changed := fastpathTV.DecMapFloat64UintV(*vp, true, d)
22434                 if changed {
22435                         *vp = v
22436                 }
22437         } else {
22438                 fastpathTV.DecMapFloat64UintV(rv2i(rv).(map[float64]uint), false, d)
22439         }
22440 }
22441 func (f fastpathT) DecMapFloat64UintX(vp *map[float64]uint, d *Decoder) {
22442         v, changed := f.DecMapFloat64UintV(*vp, true, d)
22443         if changed {
22444                 *vp = v
22445         }
22446 }
22447 func (_ fastpathT) DecMapFloat64UintV(v map[float64]uint, canChange bool,
22448         d *Decoder) (_ map[float64]uint, changed bool) {
22449         dd, esep := d.d, d.hh.hasElemSeparators()
22450         containerLen := dd.ReadMapStart()
22451         if canChange && v == nil {
22452                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
22453                 v = make(map[float64]uint, xlen)
22454                 changed = true
22455         }
22456         if containerLen == 0 {
22457                 dd.ReadMapEnd()
22458                 return v, changed
22459         }
22460         d.depthIncr()
22461         var mk float64
22462         var mv uint
22463         hasLen := containerLen > 0
22464         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22465                 if esep {
22466                         dd.ReadMapElemKey()
22467                 }
22468                 mk = dd.DecodeFloat64()
22469                 if esep {
22470                         dd.ReadMapElemValue()
22471                 }
22472                 if dd.TryDecodeAsNil() {
22473                         if v == nil {
22474                         } else if d.h.DeleteOnNilMapValue {
22475                                 delete(v, mk)
22476                         } else {
22477                                 v[mk] = 0
22478                         }
22479                         continue
22480                 }
22481                 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
22482                 if v != nil {
22483                         v[mk] = mv
22484                 }
22485         }
22486         dd.ReadMapEnd()
22487         d.depthDecr()
22488         return v, changed
22489 }
22490
22491 func (d *Decoder) fastpathDecMapFloat64Uint8R(f *codecFnInfo, rv reflect.Value) {
22492         if rv.Kind() == reflect.Ptr {
22493                 vp := rv2i(rv).(*map[float64]uint8)
22494                 v, changed := fastpathTV.DecMapFloat64Uint8V(*vp, true, d)
22495                 if changed {
22496                         *vp = v
22497                 }
22498         } else {
22499                 fastpathTV.DecMapFloat64Uint8V(rv2i(rv).(map[float64]uint8), false, d)
22500         }
22501 }
22502 func (f fastpathT) DecMapFloat64Uint8X(vp *map[float64]uint8, d *Decoder) {
22503         v, changed := f.DecMapFloat64Uint8V(*vp, true, d)
22504         if changed {
22505                 *vp = v
22506         }
22507 }
22508 func (_ fastpathT) DecMapFloat64Uint8V(v map[float64]uint8, canChange bool,
22509         d *Decoder) (_ map[float64]uint8, changed bool) {
22510         dd, esep := d.d, d.hh.hasElemSeparators()
22511         containerLen := dd.ReadMapStart()
22512         if canChange && v == nil {
22513                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
22514                 v = make(map[float64]uint8, xlen)
22515                 changed = true
22516         }
22517         if containerLen == 0 {
22518                 dd.ReadMapEnd()
22519                 return v, changed
22520         }
22521         d.depthIncr()
22522         var mk float64
22523         var mv uint8
22524         hasLen := containerLen > 0
22525         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22526                 if esep {
22527                         dd.ReadMapElemKey()
22528                 }
22529                 mk = dd.DecodeFloat64()
22530                 if esep {
22531                         dd.ReadMapElemValue()
22532                 }
22533                 if dd.TryDecodeAsNil() {
22534                         if v == nil {
22535                         } else if d.h.DeleteOnNilMapValue {
22536                                 delete(v, mk)
22537                         } else {
22538                                 v[mk] = 0
22539                         }
22540                         continue
22541                 }
22542                 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
22543                 if v != nil {
22544                         v[mk] = mv
22545                 }
22546         }
22547         dd.ReadMapEnd()
22548         d.depthDecr()
22549         return v, changed
22550 }
22551
22552 func (d *Decoder) fastpathDecMapFloat64Uint16R(f *codecFnInfo, rv reflect.Value) {
22553         if rv.Kind() == reflect.Ptr {
22554                 vp := rv2i(rv).(*map[float64]uint16)
22555                 v, changed := fastpathTV.DecMapFloat64Uint16V(*vp, true, d)
22556                 if changed {
22557                         *vp = v
22558                 }
22559         } else {
22560                 fastpathTV.DecMapFloat64Uint16V(rv2i(rv).(map[float64]uint16), false, d)
22561         }
22562 }
22563 func (f fastpathT) DecMapFloat64Uint16X(vp *map[float64]uint16, d *Decoder) {
22564         v, changed := f.DecMapFloat64Uint16V(*vp, true, d)
22565         if changed {
22566                 *vp = v
22567         }
22568 }
22569 func (_ fastpathT) DecMapFloat64Uint16V(v map[float64]uint16, canChange bool,
22570         d *Decoder) (_ map[float64]uint16, changed bool) {
22571         dd, esep := d.d, d.hh.hasElemSeparators()
22572         containerLen := dd.ReadMapStart()
22573         if canChange && v == nil {
22574                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
22575                 v = make(map[float64]uint16, xlen)
22576                 changed = true
22577         }
22578         if containerLen == 0 {
22579                 dd.ReadMapEnd()
22580                 return v, changed
22581         }
22582         d.depthIncr()
22583         var mk float64
22584         var mv uint16
22585         hasLen := containerLen > 0
22586         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22587                 if esep {
22588                         dd.ReadMapElemKey()
22589                 }
22590                 mk = dd.DecodeFloat64()
22591                 if esep {
22592                         dd.ReadMapElemValue()
22593                 }
22594                 if dd.TryDecodeAsNil() {
22595                         if v == nil {
22596                         } else if d.h.DeleteOnNilMapValue {
22597                                 delete(v, mk)
22598                         } else {
22599                                 v[mk] = 0
22600                         }
22601                         continue
22602                 }
22603                 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
22604                 if v != nil {
22605                         v[mk] = mv
22606                 }
22607         }
22608         dd.ReadMapEnd()
22609         d.depthDecr()
22610         return v, changed
22611 }
22612
22613 func (d *Decoder) fastpathDecMapFloat64Uint32R(f *codecFnInfo, rv reflect.Value) {
22614         if rv.Kind() == reflect.Ptr {
22615                 vp := rv2i(rv).(*map[float64]uint32)
22616                 v, changed := fastpathTV.DecMapFloat64Uint32V(*vp, true, d)
22617                 if changed {
22618                         *vp = v
22619                 }
22620         } else {
22621                 fastpathTV.DecMapFloat64Uint32V(rv2i(rv).(map[float64]uint32), false, d)
22622         }
22623 }
22624 func (f fastpathT) DecMapFloat64Uint32X(vp *map[float64]uint32, d *Decoder) {
22625         v, changed := f.DecMapFloat64Uint32V(*vp, true, d)
22626         if changed {
22627                 *vp = v
22628         }
22629 }
22630 func (_ fastpathT) DecMapFloat64Uint32V(v map[float64]uint32, canChange bool,
22631         d *Decoder) (_ map[float64]uint32, changed bool) {
22632         dd, esep := d.d, d.hh.hasElemSeparators()
22633         containerLen := dd.ReadMapStart()
22634         if canChange && v == nil {
22635                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
22636                 v = make(map[float64]uint32, xlen)
22637                 changed = true
22638         }
22639         if containerLen == 0 {
22640                 dd.ReadMapEnd()
22641                 return v, changed
22642         }
22643         d.depthIncr()
22644         var mk float64
22645         var mv uint32
22646         hasLen := containerLen > 0
22647         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22648                 if esep {
22649                         dd.ReadMapElemKey()
22650                 }
22651                 mk = dd.DecodeFloat64()
22652                 if esep {
22653                         dd.ReadMapElemValue()
22654                 }
22655                 if dd.TryDecodeAsNil() {
22656                         if v == nil {
22657                         } else if d.h.DeleteOnNilMapValue {
22658                                 delete(v, mk)
22659                         } else {
22660                                 v[mk] = 0
22661                         }
22662                         continue
22663                 }
22664                 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
22665                 if v != nil {
22666                         v[mk] = mv
22667                 }
22668         }
22669         dd.ReadMapEnd()
22670         d.depthDecr()
22671         return v, changed
22672 }
22673
22674 func (d *Decoder) fastpathDecMapFloat64Uint64R(f *codecFnInfo, rv reflect.Value) {
22675         if rv.Kind() == reflect.Ptr {
22676                 vp := rv2i(rv).(*map[float64]uint64)
22677                 v, changed := fastpathTV.DecMapFloat64Uint64V(*vp, true, d)
22678                 if changed {
22679                         *vp = v
22680                 }
22681         } else {
22682                 fastpathTV.DecMapFloat64Uint64V(rv2i(rv).(map[float64]uint64), false, d)
22683         }
22684 }
22685 func (f fastpathT) DecMapFloat64Uint64X(vp *map[float64]uint64, d *Decoder) {
22686         v, changed := f.DecMapFloat64Uint64V(*vp, true, d)
22687         if changed {
22688                 *vp = v
22689         }
22690 }
22691 func (_ fastpathT) DecMapFloat64Uint64V(v map[float64]uint64, canChange bool,
22692         d *Decoder) (_ map[float64]uint64, changed bool) {
22693         dd, esep := d.d, d.hh.hasElemSeparators()
22694         containerLen := dd.ReadMapStart()
22695         if canChange && v == nil {
22696                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
22697                 v = make(map[float64]uint64, xlen)
22698                 changed = true
22699         }
22700         if containerLen == 0 {
22701                 dd.ReadMapEnd()
22702                 return v, changed
22703         }
22704         d.depthIncr()
22705         var mk float64
22706         var mv uint64
22707         hasLen := containerLen > 0
22708         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22709                 if esep {
22710                         dd.ReadMapElemKey()
22711                 }
22712                 mk = dd.DecodeFloat64()
22713                 if esep {
22714                         dd.ReadMapElemValue()
22715                 }
22716                 if dd.TryDecodeAsNil() {
22717                         if v == nil {
22718                         } else if d.h.DeleteOnNilMapValue {
22719                                 delete(v, mk)
22720                         } else {
22721                                 v[mk] = 0
22722                         }
22723                         continue
22724                 }
22725                 mv = dd.DecodeUint64()
22726                 if v != nil {
22727                         v[mk] = mv
22728                 }
22729         }
22730         dd.ReadMapEnd()
22731         d.depthDecr()
22732         return v, changed
22733 }
22734
22735 func (d *Decoder) fastpathDecMapFloat64UintptrR(f *codecFnInfo, rv reflect.Value) {
22736         if rv.Kind() == reflect.Ptr {
22737                 vp := rv2i(rv).(*map[float64]uintptr)
22738                 v, changed := fastpathTV.DecMapFloat64UintptrV(*vp, true, d)
22739                 if changed {
22740                         *vp = v
22741                 }
22742         } else {
22743                 fastpathTV.DecMapFloat64UintptrV(rv2i(rv).(map[float64]uintptr), false, d)
22744         }
22745 }
22746 func (f fastpathT) DecMapFloat64UintptrX(vp *map[float64]uintptr, d *Decoder) {
22747         v, changed := f.DecMapFloat64UintptrV(*vp, true, d)
22748         if changed {
22749                 *vp = v
22750         }
22751 }
22752 func (_ fastpathT) DecMapFloat64UintptrV(v map[float64]uintptr, canChange bool,
22753         d *Decoder) (_ map[float64]uintptr, changed bool) {
22754         dd, esep := d.d, d.hh.hasElemSeparators()
22755         containerLen := dd.ReadMapStart()
22756         if canChange && v == nil {
22757                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
22758                 v = make(map[float64]uintptr, xlen)
22759                 changed = true
22760         }
22761         if containerLen == 0 {
22762                 dd.ReadMapEnd()
22763                 return v, changed
22764         }
22765         d.depthIncr()
22766         var mk float64
22767         var mv uintptr
22768         hasLen := containerLen > 0
22769         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22770                 if esep {
22771                         dd.ReadMapElemKey()
22772                 }
22773                 mk = dd.DecodeFloat64()
22774                 if esep {
22775                         dd.ReadMapElemValue()
22776                 }
22777                 if dd.TryDecodeAsNil() {
22778                         if v == nil {
22779                         } else if d.h.DeleteOnNilMapValue {
22780                                 delete(v, mk)
22781                         } else {
22782                                 v[mk] = 0
22783                         }
22784                         continue
22785                 }
22786                 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
22787                 if v != nil {
22788                         v[mk] = mv
22789                 }
22790         }
22791         dd.ReadMapEnd()
22792         d.depthDecr()
22793         return v, changed
22794 }
22795
22796 func (d *Decoder) fastpathDecMapFloat64IntR(f *codecFnInfo, rv reflect.Value) {
22797         if rv.Kind() == reflect.Ptr {
22798                 vp := rv2i(rv).(*map[float64]int)
22799                 v, changed := fastpathTV.DecMapFloat64IntV(*vp, true, d)
22800                 if changed {
22801                         *vp = v
22802                 }
22803         } else {
22804                 fastpathTV.DecMapFloat64IntV(rv2i(rv).(map[float64]int), false, d)
22805         }
22806 }
22807 func (f fastpathT) DecMapFloat64IntX(vp *map[float64]int, d *Decoder) {
22808         v, changed := f.DecMapFloat64IntV(*vp, true, d)
22809         if changed {
22810                 *vp = v
22811         }
22812 }
22813 func (_ fastpathT) DecMapFloat64IntV(v map[float64]int, canChange bool,
22814         d *Decoder) (_ map[float64]int, changed bool) {
22815         dd, esep := d.d, d.hh.hasElemSeparators()
22816         containerLen := dd.ReadMapStart()
22817         if canChange && v == nil {
22818                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
22819                 v = make(map[float64]int, xlen)
22820                 changed = true
22821         }
22822         if containerLen == 0 {
22823                 dd.ReadMapEnd()
22824                 return v, changed
22825         }
22826         d.depthIncr()
22827         var mk float64
22828         var mv int
22829         hasLen := containerLen > 0
22830         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22831                 if esep {
22832                         dd.ReadMapElemKey()
22833                 }
22834                 mk = dd.DecodeFloat64()
22835                 if esep {
22836                         dd.ReadMapElemValue()
22837                 }
22838                 if dd.TryDecodeAsNil() {
22839                         if v == nil {
22840                         } else if d.h.DeleteOnNilMapValue {
22841                                 delete(v, mk)
22842                         } else {
22843                                 v[mk] = 0
22844                         }
22845                         continue
22846                 }
22847                 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
22848                 if v != nil {
22849                         v[mk] = mv
22850                 }
22851         }
22852         dd.ReadMapEnd()
22853         d.depthDecr()
22854         return v, changed
22855 }
22856
22857 func (d *Decoder) fastpathDecMapFloat64Int8R(f *codecFnInfo, rv reflect.Value) {
22858         if rv.Kind() == reflect.Ptr {
22859                 vp := rv2i(rv).(*map[float64]int8)
22860                 v, changed := fastpathTV.DecMapFloat64Int8V(*vp, true, d)
22861                 if changed {
22862                         *vp = v
22863                 }
22864         } else {
22865                 fastpathTV.DecMapFloat64Int8V(rv2i(rv).(map[float64]int8), false, d)
22866         }
22867 }
22868 func (f fastpathT) DecMapFloat64Int8X(vp *map[float64]int8, d *Decoder) {
22869         v, changed := f.DecMapFloat64Int8V(*vp, true, d)
22870         if changed {
22871                 *vp = v
22872         }
22873 }
22874 func (_ fastpathT) DecMapFloat64Int8V(v map[float64]int8, canChange bool,
22875         d *Decoder) (_ map[float64]int8, changed bool) {
22876         dd, esep := d.d, d.hh.hasElemSeparators()
22877         containerLen := dd.ReadMapStart()
22878         if canChange && v == nil {
22879                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
22880                 v = make(map[float64]int8, xlen)
22881                 changed = true
22882         }
22883         if containerLen == 0 {
22884                 dd.ReadMapEnd()
22885                 return v, changed
22886         }
22887         d.depthIncr()
22888         var mk float64
22889         var mv int8
22890         hasLen := containerLen > 0
22891         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22892                 if esep {
22893                         dd.ReadMapElemKey()
22894                 }
22895                 mk = dd.DecodeFloat64()
22896                 if esep {
22897                         dd.ReadMapElemValue()
22898                 }
22899                 if dd.TryDecodeAsNil() {
22900                         if v == nil {
22901                         } else if d.h.DeleteOnNilMapValue {
22902                                 delete(v, mk)
22903                         } else {
22904                                 v[mk] = 0
22905                         }
22906                         continue
22907                 }
22908                 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
22909                 if v != nil {
22910                         v[mk] = mv
22911                 }
22912         }
22913         dd.ReadMapEnd()
22914         d.depthDecr()
22915         return v, changed
22916 }
22917
22918 func (d *Decoder) fastpathDecMapFloat64Int16R(f *codecFnInfo, rv reflect.Value) {
22919         if rv.Kind() == reflect.Ptr {
22920                 vp := rv2i(rv).(*map[float64]int16)
22921                 v, changed := fastpathTV.DecMapFloat64Int16V(*vp, true, d)
22922                 if changed {
22923                         *vp = v
22924                 }
22925         } else {
22926                 fastpathTV.DecMapFloat64Int16V(rv2i(rv).(map[float64]int16), false, d)
22927         }
22928 }
22929 func (f fastpathT) DecMapFloat64Int16X(vp *map[float64]int16, d *Decoder) {
22930         v, changed := f.DecMapFloat64Int16V(*vp, true, d)
22931         if changed {
22932                 *vp = v
22933         }
22934 }
22935 func (_ fastpathT) DecMapFloat64Int16V(v map[float64]int16, canChange bool,
22936         d *Decoder) (_ map[float64]int16, changed bool) {
22937         dd, esep := d.d, d.hh.hasElemSeparators()
22938         containerLen := dd.ReadMapStart()
22939         if canChange && v == nil {
22940                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
22941                 v = make(map[float64]int16, xlen)
22942                 changed = true
22943         }
22944         if containerLen == 0 {
22945                 dd.ReadMapEnd()
22946                 return v, changed
22947         }
22948         d.depthIncr()
22949         var mk float64
22950         var mv int16
22951         hasLen := containerLen > 0
22952         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22953                 if esep {
22954                         dd.ReadMapElemKey()
22955                 }
22956                 mk = dd.DecodeFloat64()
22957                 if esep {
22958                         dd.ReadMapElemValue()
22959                 }
22960                 if dd.TryDecodeAsNil() {
22961                         if v == nil {
22962                         } else if d.h.DeleteOnNilMapValue {
22963                                 delete(v, mk)
22964                         } else {
22965                                 v[mk] = 0
22966                         }
22967                         continue
22968                 }
22969                 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
22970                 if v != nil {
22971                         v[mk] = mv
22972                 }
22973         }
22974         dd.ReadMapEnd()
22975         d.depthDecr()
22976         return v, changed
22977 }
22978
22979 func (d *Decoder) fastpathDecMapFloat64Int32R(f *codecFnInfo, rv reflect.Value) {
22980         if rv.Kind() == reflect.Ptr {
22981                 vp := rv2i(rv).(*map[float64]int32)
22982                 v, changed := fastpathTV.DecMapFloat64Int32V(*vp, true, d)
22983                 if changed {
22984                         *vp = v
22985                 }
22986         } else {
22987                 fastpathTV.DecMapFloat64Int32V(rv2i(rv).(map[float64]int32), false, d)
22988         }
22989 }
22990 func (f fastpathT) DecMapFloat64Int32X(vp *map[float64]int32, d *Decoder) {
22991         v, changed := f.DecMapFloat64Int32V(*vp, true, d)
22992         if changed {
22993                 *vp = v
22994         }
22995 }
22996 func (_ fastpathT) DecMapFloat64Int32V(v map[float64]int32, canChange bool,
22997         d *Decoder) (_ map[float64]int32, changed bool) {
22998         dd, esep := d.d, d.hh.hasElemSeparators()
22999         containerLen := dd.ReadMapStart()
23000         if canChange && v == nil {
23001                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
23002                 v = make(map[float64]int32, xlen)
23003                 changed = true
23004         }
23005         if containerLen == 0 {
23006                 dd.ReadMapEnd()
23007                 return v, changed
23008         }
23009         d.depthIncr()
23010         var mk float64
23011         var mv int32
23012         hasLen := containerLen > 0
23013         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23014                 if esep {
23015                         dd.ReadMapElemKey()
23016                 }
23017                 mk = dd.DecodeFloat64()
23018                 if esep {
23019                         dd.ReadMapElemValue()
23020                 }
23021                 if dd.TryDecodeAsNil() {
23022                         if v == nil {
23023                         } else if d.h.DeleteOnNilMapValue {
23024                                 delete(v, mk)
23025                         } else {
23026                                 v[mk] = 0
23027                         }
23028                         continue
23029                 }
23030                 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
23031                 if v != nil {
23032                         v[mk] = mv
23033                 }
23034         }
23035         dd.ReadMapEnd()
23036         d.depthDecr()
23037         return v, changed
23038 }
23039
23040 func (d *Decoder) fastpathDecMapFloat64Int64R(f *codecFnInfo, rv reflect.Value) {
23041         if rv.Kind() == reflect.Ptr {
23042                 vp := rv2i(rv).(*map[float64]int64)
23043                 v, changed := fastpathTV.DecMapFloat64Int64V(*vp, true, d)
23044                 if changed {
23045                         *vp = v
23046                 }
23047         } else {
23048                 fastpathTV.DecMapFloat64Int64V(rv2i(rv).(map[float64]int64), false, d)
23049         }
23050 }
23051 func (f fastpathT) DecMapFloat64Int64X(vp *map[float64]int64, d *Decoder) {
23052         v, changed := f.DecMapFloat64Int64V(*vp, true, d)
23053         if changed {
23054                 *vp = v
23055         }
23056 }
23057 func (_ fastpathT) DecMapFloat64Int64V(v map[float64]int64, canChange bool,
23058         d *Decoder) (_ map[float64]int64, changed bool) {
23059         dd, esep := d.d, d.hh.hasElemSeparators()
23060         containerLen := dd.ReadMapStart()
23061         if canChange && v == nil {
23062                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
23063                 v = make(map[float64]int64, xlen)
23064                 changed = true
23065         }
23066         if containerLen == 0 {
23067                 dd.ReadMapEnd()
23068                 return v, changed
23069         }
23070         d.depthIncr()
23071         var mk float64
23072         var mv int64
23073         hasLen := containerLen > 0
23074         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23075                 if esep {
23076                         dd.ReadMapElemKey()
23077                 }
23078                 mk = dd.DecodeFloat64()
23079                 if esep {
23080                         dd.ReadMapElemValue()
23081                 }
23082                 if dd.TryDecodeAsNil() {
23083                         if v == nil {
23084                         } else if d.h.DeleteOnNilMapValue {
23085                                 delete(v, mk)
23086                         } else {
23087                                 v[mk] = 0
23088                         }
23089                         continue
23090                 }
23091                 mv = dd.DecodeInt64()
23092                 if v != nil {
23093                         v[mk] = mv
23094                 }
23095         }
23096         dd.ReadMapEnd()
23097         d.depthDecr()
23098         return v, changed
23099 }
23100
23101 func (d *Decoder) fastpathDecMapFloat64Float32R(f *codecFnInfo, rv reflect.Value) {
23102         if rv.Kind() == reflect.Ptr {
23103                 vp := rv2i(rv).(*map[float64]float32)
23104                 v, changed := fastpathTV.DecMapFloat64Float32V(*vp, true, d)
23105                 if changed {
23106                         *vp = v
23107                 }
23108         } else {
23109                 fastpathTV.DecMapFloat64Float32V(rv2i(rv).(map[float64]float32), false, d)
23110         }
23111 }
23112 func (f fastpathT) DecMapFloat64Float32X(vp *map[float64]float32, d *Decoder) {
23113         v, changed := f.DecMapFloat64Float32V(*vp, true, d)
23114         if changed {
23115                 *vp = v
23116         }
23117 }
23118 func (_ fastpathT) DecMapFloat64Float32V(v map[float64]float32, canChange bool,
23119         d *Decoder) (_ map[float64]float32, changed bool) {
23120         dd, esep := d.d, d.hh.hasElemSeparators()
23121         containerLen := dd.ReadMapStart()
23122         if canChange && v == nil {
23123                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
23124                 v = make(map[float64]float32, xlen)
23125                 changed = true
23126         }
23127         if containerLen == 0 {
23128                 dd.ReadMapEnd()
23129                 return v, changed
23130         }
23131         d.depthIncr()
23132         var mk float64
23133         var mv float32
23134         hasLen := containerLen > 0
23135         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23136                 if esep {
23137                         dd.ReadMapElemKey()
23138                 }
23139                 mk = dd.DecodeFloat64()
23140                 if esep {
23141                         dd.ReadMapElemValue()
23142                 }
23143                 if dd.TryDecodeAsNil() {
23144                         if v == nil {
23145                         } else if d.h.DeleteOnNilMapValue {
23146                                 delete(v, mk)
23147                         } else {
23148                                 v[mk] = 0
23149                         }
23150                         continue
23151                 }
23152                 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
23153                 if v != nil {
23154                         v[mk] = mv
23155                 }
23156         }
23157         dd.ReadMapEnd()
23158         d.depthDecr()
23159         return v, changed
23160 }
23161
23162 func (d *Decoder) fastpathDecMapFloat64Float64R(f *codecFnInfo, rv reflect.Value) {
23163         if rv.Kind() == reflect.Ptr {
23164                 vp := rv2i(rv).(*map[float64]float64)
23165                 v, changed := fastpathTV.DecMapFloat64Float64V(*vp, true, d)
23166                 if changed {
23167                         *vp = v
23168                 }
23169         } else {
23170                 fastpathTV.DecMapFloat64Float64V(rv2i(rv).(map[float64]float64), false, d)
23171         }
23172 }
23173 func (f fastpathT) DecMapFloat64Float64X(vp *map[float64]float64, d *Decoder) {
23174         v, changed := f.DecMapFloat64Float64V(*vp, true, d)
23175         if changed {
23176                 *vp = v
23177         }
23178 }
23179 func (_ fastpathT) DecMapFloat64Float64V(v map[float64]float64, canChange bool,
23180         d *Decoder) (_ map[float64]float64, changed bool) {
23181         dd, esep := d.d, d.hh.hasElemSeparators()
23182         containerLen := dd.ReadMapStart()
23183         if canChange && v == nil {
23184                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
23185                 v = make(map[float64]float64, xlen)
23186                 changed = true
23187         }
23188         if containerLen == 0 {
23189                 dd.ReadMapEnd()
23190                 return v, changed
23191         }
23192         d.depthIncr()
23193         var mk float64
23194         var mv float64
23195         hasLen := containerLen > 0
23196         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23197                 if esep {
23198                         dd.ReadMapElemKey()
23199                 }
23200                 mk = dd.DecodeFloat64()
23201                 if esep {
23202                         dd.ReadMapElemValue()
23203                 }
23204                 if dd.TryDecodeAsNil() {
23205                         if v == nil {
23206                         } else if d.h.DeleteOnNilMapValue {
23207                                 delete(v, mk)
23208                         } else {
23209                                 v[mk] = 0
23210                         }
23211                         continue
23212                 }
23213                 mv = dd.DecodeFloat64()
23214                 if v != nil {
23215                         v[mk] = mv
23216                 }
23217         }
23218         dd.ReadMapEnd()
23219         d.depthDecr()
23220         return v, changed
23221 }
23222
23223 func (d *Decoder) fastpathDecMapFloat64BoolR(f *codecFnInfo, rv reflect.Value) {
23224         if rv.Kind() == reflect.Ptr {
23225                 vp := rv2i(rv).(*map[float64]bool)
23226                 v, changed := fastpathTV.DecMapFloat64BoolV(*vp, true, d)
23227                 if changed {
23228                         *vp = v
23229                 }
23230         } else {
23231                 fastpathTV.DecMapFloat64BoolV(rv2i(rv).(map[float64]bool), false, d)
23232         }
23233 }
23234 func (f fastpathT) DecMapFloat64BoolX(vp *map[float64]bool, d *Decoder) {
23235         v, changed := f.DecMapFloat64BoolV(*vp, true, d)
23236         if changed {
23237                 *vp = v
23238         }
23239 }
23240 func (_ fastpathT) DecMapFloat64BoolV(v map[float64]bool, canChange bool,
23241         d *Decoder) (_ map[float64]bool, changed bool) {
23242         dd, esep := d.d, d.hh.hasElemSeparators()
23243         containerLen := dd.ReadMapStart()
23244         if canChange && v == nil {
23245                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
23246                 v = make(map[float64]bool, xlen)
23247                 changed = true
23248         }
23249         if containerLen == 0 {
23250                 dd.ReadMapEnd()
23251                 return v, changed
23252         }
23253         d.depthIncr()
23254         var mk float64
23255         var mv bool
23256         hasLen := containerLen > 0
23257         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23258                 if esep {
23259                         dd.ReadMapElemKey()
23260                 }
23261                 mk = dd.DecodeFloat64()
23262                 if esep {
23263                         dd.ReadMapElemValue()
23264                 }
23265                 if dd.TryDecodeAsNil() {
23266                         if v == nil {
23267                         } else if d.h.DeleteOnNilMapValue {
23268                                 delete(v, mk)
23269                         } else {
23270                                 v[mk] = false
23271                         }
23272                         continue
23273                 }
23274                 mv = dd.DecodeBool()
23275                 if v != nil {
23276                         v[mk] = mv
23277                 }
23278         }
23279         dd.ReadMapEnd()
23280         d.depthDecr()
23281         return v, changed
23282 }
23283
23284 func (d *Decoder) fastpathDecMapUintIntfR(f *codecFnInfo, rv reflect.Value) {
23285         if rv.Kind() == reflect.Ptr {
23286                 vp := rv2i(rv).(*map[uint]interface{})
23287                 v, changed := fastpathTV.DecMapUintIntfV(*vp, true, d)
23288                 if changed {
23289                         *vp = v
23290                 }
23291         } else {
23292                 fastpathTV.DecMapUintIntfV(rv2i(rv).(map[uint]interface{}), false, d)
23293         }
23294 }
23295 func (f fastpathT) DecMapUintIntfX(vp *map[uint]interface{}, d *Decoder) {
23296         v, changed := f.DecMapUintIntfV(*vp, true, d)
23297         if changed {
23298                 *vp = v
23299         }
23300 }
23301 func (_ fastpathT) DecMapUintIntfV(v map[uint]interface{}, canChange bool,
23302         d *Decoder) (_ map[uint]interface{}, changed bool) {
23303         dd, esep := d.d, d.hh.hasElemSeparators()
23304         containerLen := dd.ReadMapStart()
23305         if canChange && v == nil {
23306                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
23307                 v = make(map[uint]interface{}, xlen)
23308                 changed = true
23309         }
23310         if containerLen == 0 {
23311                 dd.ReadMapEnd()
23312                 return v, changed
23313         }
23314         d.depthIncr()
23315         mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
23316         var mk uint
23317         var mv interface{}
23318         hasLen := containerLen > 0
23319         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23320                 if esep {
23321                         dd.ReadMapElemKey()
23322                 }
23323                 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23324                 if esep {
23325                         dd.ReadMapElemValue()
23326                 }
23327                 if dd.TryDecodeAsNil() {
23328                         if v == nil {
23329                         } else if d.h.DeleteOnNilMapValue {
23330                                 delete(v, mk)
23331                         } else {
23332                                 v[mk] = nil
23333                         }
23334                         continue
23335                 }
23336                 if mapGet {
23337                         mv = v[mk]
23338                 } else {
23339                         mv = nil
23340                 }
23341                 d.decode(&mv)
23342                 if v != nil {
23343                         v[mk] = mv
23344                 }
23345         }
23346         dd.ReadMapEnd()
23347         d.depthDecr()
23348         return v, changed
23349 }
23350
23351 func (d *Decoder) fastpathDecMapUintStringR(f *codecFnInfo, rv reflect.Value) {
23352         if rv.Kind() == reflect.Ptr {
23353                 vp := rv2i(rv).(*map[uint]string)
23354                 v, changed := fastpathTV.DecMapUintStringV(*vp, true, d)
23355                 if changed {
23356                         *vp = v
23357                 }
23358         } else {
23359                 fastpathTV.DecMapUintStringV(rv2i(rv).(map[uint]string), false, d)
23360         }
23361 }
23362 func (f fastpathT) DecMapUintStringX(vp *map[uint]string, d *Decoder) {
23363         v, changed := f.DecMapUintStringV(*vp, true, d)
23364         if changed {
23365                 *vp = v
23366         }
23367 }
23368 func (_ fastpathT) DecMapUintStringV(v map[uint]string, canChange bool,
23369         d *Decoder) (_ map[uint]string, changed bool) {
23370         dd, esep := d.d, d.hh.hasElemSeparators()
23371         containerLen := dd.ReadMapStart()
23372         if canChange && v == nil {
23373                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
23374                 v = make(map[uint]string, xlen)
23375                 changed = true
23376         }
23377         if containerLen == 0 {
23378                 dd.ReadMapEnd()
23379                 return v, changed
23380         }
23381         d.depthIncr()
23382         var mk uint
23383         var mv string
23384         hasLen := containerLen > 0
23385         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23386                 if esep {
23387                         dd.ReadMapElemKey()
23388                 }
23389                 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23390                 if esep {
23391                         dd.ReadMapElemValue()
23392                 }
23393                 if dd.TryDecodeAsNil() {
23394                         if v == nil {
23395                         } else if d.h.DeleteOnNilMapValue {
23396                                 delete(v, mk)
23397                         } else {
23398                                 v[mk] = ""
23399                         }
23400                         continue
23401                 }
23402                 mv = dd.DecodeString()
23403                 if v != nil {
23404                         v[mk] = mv
23405                 }
23406         }
23407         dd.ReadMapEnd()
23408         d.depthDecr()
23409         return v, changed
23410 }
23411
23412 func (d *Decoder) fastpathDecMapUintUintR(f *codecFnInfo, rv reflect.Value) {
23413         if rv.Kind() == reflect.Ptr {
23414                 vp := rv2i(rv).(*map[uint]uint)
23415                 v, changed := fastpathTV.DecMapUintUintV(*vp, true, d)
23416                 if changed {
23417                         *vp = v
23418                 }
23419         } else {
23420                 fastpathTV.DecMapUintUintV(rv2i(rv).(map[uint]uint), false, d)
23421         }
23422 }
23423 func (f fastpathT) DecMapUintUintX(vp *map[uint]uint, d *Decoder) {
23424         v, changed := f.DecMapUintUintV(*vp, true, d)
23425         if changed {
23426                 *vp = v
23427         }
23428 }
23429 func (_ fastpathT) DecMapUintUintV(v map[uint]uint, canChange bool,
23430         d *Decoder) (_ map[uint]uint, changed bool) {
23431         dd, esep := d.d, d.hh.hasElemSeparators()
23432         containerLen := dd.ReadMapStart()
23433         if canChange && v == nil {
23434                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
23435                 v = make(map[uint]uint, xlen)
23436                 changed = true
23437         }
23438         if containerLen == 0 {
23439                 dd.ReadMapEnd()
23440                 return v, changed
23441         }
23442         d.depthIncr()
23443         var mk uint
23444         var mv uint
23445         hasLen := containerLen > 0
23446         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23447                 if esep {
23448                         dd.ReadMapElemKey()
23449                 }
23450                 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23451                 if esep {
23452                         dd.ReadMapElemValue()
23453                 }
23454                 if dd.TryDecodeAsNil() {
23455                         if v == nil {
23456                         } else if d.h.DeleteOnNilMapValue {
23457                                 delete(v, mk)
23458                         } else {
23459                                 v[mk] = 0
23460                         }
23461                         continue
23462                 }
23463                 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23464                 if v != nil {
23465                         v[mk] = mv
23466                 }
23467         }
23468         dd.ReadMapEnd()
23469         d.depthDecr()
23470         return v, changed
23471 }
23472
23473 func (d *Decoder) fastpathDecMapUintUint8R(f *codecFnInfo, rv reflect.Value) {
23474         if rv.Kind() == reflect.Ptr {
23475                 vp := rv2i(rv).(*map[uint]uint8)
23476                 v, changed := fastpathTV.DecMapUintUint8V(*vp, true, d)
23477                 if changed {
23478                         *vp = v
23479                 }
23480         } else {
23481                 fastpathTV.DecMapUintUint8V(rv2i(rv).(map[uint]uint8), false, d)
23482         }
23483 }
23484 func (f fastpathT) DecMapUintUint8X(vp *map[uint]uint8, d *Decoder) {
23485         v, changed := f.DecMapUintUint8V(*vp, true, d)
23486         if changed {
23487                 *vp = v
23488         }
23489 }
23490 func (_ fastpathT) DecMapUintUint8V(v map[uint]uint8, canChange bool,
23491         d *Decoder) (_ map[uint]uint8, changed bool) {
23492         dd, esep := d.d, d.hh.hasElemSeparators()
23493         containerLen := dd.ReadMapStart()
23494         if canChange && v == nil {
23495                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
23496                 v = make(map[uint]uint8, xlen)
23497                 changed = true
23498         }
23499         if containerLen == 0 {
23500                 dd.ReadMapEnd()
23501                 return v, changed
23502         }
23503         d.depthIncr()
23504         var mk uint
23505         var mv uint8
23506         hasLen := containerLen > 0
23507         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23508                 if esep {
23509                         dd.ReadMapElemKey()
23510                 }
23511                 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23512                 if esep {
23513                         dd.ReadMapElemValue()
23514                 }
23515                 if dd.TryDecodeAsNil() {
23516                         if v == nil {
23517                         } else if d.h.DeleteOnNilMapValue {
23518                                 delete(v, mk)
23519                         } else {
23520                                 v[mk] = 0
23521                         }
23522                         continue
23523                 }
23524                 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
23525                 if v != nil {
23526                         v[mk] = mv
23527                 }
23528         }
23529         dd.ReadMapEnd()
23530         d.depthDecr()
23531         return v, changed
23532 }
23533
23534 func (d *Decoder) fastpathDecMapUintUint16R(f *codecFnInfo, rv reflect.Value) {
23535         if rv.Kind() == reflect.Ptr {
23536                 vp := rv2i(rv).(*map[uint]uint16)
23537                 v, changed := fastpathTV.DecMapUintUint16V(*vp, true, d)
23538                 if changed {
23539                         *vp = v
23540                 }
23541         } else {
23542                 fastpathTV.DecMapUintUint16V(rv2i(rv).(map[uint]uint16), false, d)
23543         }
23544 }
23545 func (f fastpathT) DecMapUintUint16X(vp *map[uint]uint16, d *Decoder) {
23546         v, changed := f.DecMapUintUint16V(*vp, true, d)
23547         if changed {
23548                 *vp = v
23549         }
23550 }
23551 func (_ fastpathT) DecMapUintUint16V(v map[uint]uint16, canChange bool,
23552         d *Decoder) (_ map[uint]uint16, changed bool) {
23553         dd, esep := d.d, d.hh.hasElemSeparators()
23554         containerLen := dd.ReadMapStart()
23555         if canChange && v == nil {
23556                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
23557                 v = make(map[uint]uint16, xlen)
23558                 changed = true
23559         }
23560         if containerLen == 0 {
23561                 dd.ReadMapEnd()
23562                 return v, changed
23563         }
23564         d.depthIncr()
23565         var mk uint
23566         var mv uint16
23567         hasLen := containerLen > 0
23568         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23569                 if esep {
23570                         dd.ReadMapElemKey()
23571                 }
23572                 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23573                 if esep {
23574                         dd.ReadMapElemValue()
23575                 }
23576                 if dd.TryDecodeAsNil() {
23577                         if v == nil {
23578                         } else if d.h.DeleteOnNilMapValue {
23579                                 delete(v, mk)
23580                         } else {
23581                                 v[mk] = 0
23582                         }
23583                         continue
23584                 }
23585                 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
23586                 if v != nil {
23587                         v[mk] = mv
23588                 }
23589         }
23590         dd.ReadMapEnd()
23591         d.depthDecr()
23592         return v, changed
23593 }
23594
23595 func (d *Decoder) fastpathDecMapUintUint32R(f *codecFnInfo, rv reflect.Value) {
23596         if rv.Kind() == reflect.Ptr {
23597                 vp := rv2i(rv).(*map[uint]uint32)
23598                 v, changed := fastpathTV.DecMapUintUint32V(*vp, true, d)
23599                 if changed {
23600                         *vp = v
23601                 }
23602         } else {
23603                 fastpathTV.DecMapUintUint32V(rv2i(rv).(map[uint]uint32), false, d)
23604         }
23605 }
23606 func (f fastpathT) DecMapUintUint32X(vp *map[uint]uint32, d *Decoder) {
23607         v, changed := f.DecMapUintUint32V(*vp, true, d)
23608         if changed {
23609                 *vp = v
23610         }
23611 }
23612 func (_ fastpathT) DecMapUintUint32V(v map[uint]uint32, canChange bool,
23613         d *Decoder) (_ map[uint]uint32, changed bool) {
23614         dd, esep := d.d, d.hh.hasElemSeparators()
23615         containerLen := dd.ReadMapStart()
23616         if canChange && v == nil {
23617                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
23618                 v = make(map[uint]uint32, xlen)
23619                 changed = true
23620         }
23621         if containerLen == 0 {
23622                 dd.ReadMapEnd()
23623                 return v, changed
23624         }
23625         d.depthIncr()
23626         var mk uint
23627         var mv uint32
23628         hasLen := containerLen > 0
23629         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23630                 if esep {
23631                         dd.ReadMapElemKey()
23632                 }
23633                 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23634                 if esep {
23635                         dd.ReadMapElemValue()
23636                 }
23637                 if dd.TryDecodeAsNil() {
23638                         if v == nil {
23639                         } else if d.h.DeleteOnNilMapValue {
23640                                 delete(v, mk)
23641                         } else {
23642                                 v[mk] = 0
23643                         }
23644                         continue
23645                 }
23646                 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
23647                 if v != nil {
23648                         v[mk] = mv
23649                 }
23650         }
23651         dd.ReadMapEnd()
23652         d.depthDecr()
23653         return v, changed
23654 }
23655
23656 func (d *Decoder) fastpathDecMapUintUint64R(f *codecFnInfo, rv reflect.Value) {
23657         if rv.Kind() == reflect.Ptr {
23658                 vp := rv2i(rv).(*map[uint]uint64)
23659                 v, changed := fastpathTV.DecMapUintUint64V(*vp, true, d)
23660                 if changed {
23661                         *vp = v
23662                 }
23663         } else {
23664                 fastpathTV.DecMapUintUint64V(rv2i(rv).(map[uint]uint64), false, d)
23665         }
23666 }
23667 func (f fastpathT) DecMapUintUint64X(vp *map[uint]uint64, d *Decoder) {
23668         v, changed := f.DecMapUintUint64V(*vp, true, d)
23669         if changed {
23670                 *vp = v
23671         }
23672 }
23673 func (_ fastpathT) DecMapUintUint64V(v map[uint]uint64, canChange bool,
23674         d *Decoder) (_ map[uint]uint64, changed bool) {
23675         dd, esep := d.d, d.hh.hasElemSeparators()
23676         containerLen := dd.ReadMapStart()
23677         if canChange && v == nil {
23678                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
23679                 v = make(map[uint]uint64, xlen)
23680                 changed = true
23681         }
23682         if containerLen == 0 {
23683                 dd.ReadMapEnd()
23684                 return v, changed
23685         }
23686         d.depthIncr()
23687         var mk uint
23688         var mv uint64
23689         hasLen := containerLen > 0
23690         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23691                 if esep {
23692                         dd.ReadMapElemKey()
23693                 }
23694                 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23695                 if esep {
23696                         dd.ReadMapElemValue()
23697                 }
23698                 if dd.TryDecodeAsNil() {
23699                         if v == nil {
23700                         } else if d.h.DeleteOnNilMapValue {
23701                                 delete(v, mk)
23702                         } else {
23703                                 v[mk] = 0
23704                         }
23705                         continue
23706                 }
23707                 mv = dd.DecodeUint64()
23708                 if v != nil {
23709                         v[mk] = mv
23710                 }
23711         }
23712         dd.ReadMapEnd()
23713         d.depthDecr()
23714         return v, changed
23715 }
23716
23717 func (d *Decoder) fastpathDecMapUintUintptrR(f *codecFnInfo, rv reflect.Value) {
23718         if rv.Kind() == reflect.Ptr {
23719                 vp := rv2i(rv).(*map[uint]uintptr)
23720                 v, changed := fastpathTV.DecMapUintUintptrV(*vp, true, d)
23721                 if changed {
23722                         *vp = v
23723                 }
23724         } else {
23725                 fastpathTV.DecMapUintUintptrV(rv2i(rv).(map[uint]uintptr), false, d)
23726         }
23727 }
23728 func (f fastpathT) DecMapUintUintptrX(vp *map[uint]uintptr, d *Decoder) {
23729         v, changed := f.DecMapUintUintptrV(*vp, true, d)
23730         if changed {
23731                 *vp = v
23732         }
23733 }
23734 func (_ fastpathT) DecMapUintUintptrV(v map[uint]uintptr, canChange bool,
23735         d *Decoder) (_ map[uint]uintptr, changed bool) {
23736         dd, esep := d.d, d.hh.hasElemSeparators()
23737         containerLen := dd.ReadMapStart()
23738         if canChange && v == nil {
23739                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
23740                 v = make(map[uint]uintptr, xlen)
23741                 changed = true
23742         }
23743         if containerLen == 0 {
23744                 dd.ReadMapEnd()
23745                 return v, changed
23746         }
23747         d.depthIncr()
23748         var mk uint
23749         var mv uintptr
23750         hasLen := containerLen > 0
23751         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23752                 if esep {
23753                         dd.ReadMapElemKey()
23754                 }
23755                 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23756                 if esep {
23757                         dd.ReadMapElemValue()
23758                 }
23759                 if dd.TryDecodeAsNil() {
23760                         if v == nil {
23761                         } else if d.h.DeleteOnNilMapValue {
23762                                 delete(v, mk)
23763                         } else {
23764                                 v[mk] = 0
23765                         }
23766                         continue
23767                 }
23768                 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23769                 if v != nil {
23770                         v[mk] = mv
23771                 }
23772         }
23773         dd.ReadMapEnd()
23774         d.depthDecr()
23775         return v, changed
23776 }
23777
23778 func (d *Decoder) fastpathDecMapUintIntR(f *codecFnInfo, rv reflect.Value) {
23779         if rv.Kind() == reflect.Ptr {
23780                 vp := rv2i(rv).(*map[uint]int)
23781                 v, changed := fastpathTV.DecMapUintIntV(*vp, true, d)
23782                 if changed {
23783                         *vp = v
23784                 }
23785         } else {
23786                 fastpathTV.DecMapUintIntV(rv2i(rv).(map[uint]int), false, d)
23787         }
23788 }
23789 func (f fastpathT) DecMapUintIntX(vp *map[uint]int, d *Decoder) {
23790         v, changed := f.DecMapUintIntV(*vp, true, d)
23791         if changed {
23792                 *vp = v
23793         }
23794 }
23795 func (_ fastpathT) DecMapUintIntV(v map[uint]int, canChange bool,
23796         d *Decoder) (_ map[uint]int, changed bool) {
23797         dd, esep := d.d, d.hh.hasElemSeparators()
23798         containerLen := dd.ReadMapStart()
23799         if canChange && v == nil {
23800                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
23801                 v = make(map[uint]int, xlen)
23802                 changed = true
23803         }
23804         if containerLen == 0 {
23805                 dd.ReadMapEnd()
23806                 return v, changed
23807         }
23808         d.depthIncr()
23809         var mk uint
23810         var mv int
23811         hasLen := containerLen > 0
23812         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23813                 if esep {
23814                         dd.ReadMapElemKey()
23815                 }
23816                 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23817                 if esep {
23818                         dd.ReadMapElemValue()
23819                 }
23820                 if dd.TryDecodeAsNil() {
23821                         if v == nil {
23822                         } else if d.h.DeleteOnNilMapValue {
23823                                 delete(v, mk)
23824                         } else {
23825                                 v[mk] = 0
23826                         }
23827                         continue
23828                 }
23829                 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
23830                 if v != nil {
23831                         v[mk] = mv
23832                 }
23833         }
23834         dd.ReadMapEnd()
23835         d.depthDecr()
23836         return v, changed
23837 }
23838
23839 func (d *Decoder) fastpathDecMapUintInt8R(f *codecFnInfo, rv reflect.Value) {
23840         if rv.Kind() == reflect.Ptr {
23841                 vp := rv2i(rv).(*map[uint]int8)
23842                 v, changed := fastpathTV.DecMapUintInt8V(*vp, true, d)
23843                 if changed {
23844                         *vp = v
23845                 }
23846         } else {
23847                 fastpathTV.DecMapUintInt8V(rv2i(rv).(map[uint]int8), false, d)
23848         }
23849 }
23850 func (f fastpathT) DecMapUintInt8X(vp *map[uint]int8, d *Decoder) {
23851         v, changed := f.DecMapUintInt8V(*vp, true, d)
23852         if changed {
23853                 *vp = v
23854         }
23855 }
23856 func (_ fastpathT) DecMapUintInt8V(v map[uint]int8, canChange bool,
23857         d *Decoder) (_ map[uint]int8, changed bool) {
23858         dd, esep := d.d, d.hh.hasElemSeparators()
23859         containerLen := dd.ReadMapStart()
23860         if canChange && v == nil {
23861                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
23862                 v = make(map[uint]int8, xlen)
23863                 changed = true
23864         }
23865         if containerLen == 0 {
23866                 dd.ReadMapEnd()
23867                 return v, changed
23868         }
23869         d.depthIncr()
23870         var mk uint
23871         var mv int8
23872         hasLen := containerLen > 0
23873         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23874                 if esep {
23875                         dd.ReadMapElemKey()
23876                 }
23877                 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23878                 if esep {
23879                         dd.ReadMapElemValue()
23880                 }
23881                 if dd.TryDecodeAsNil() {
23882                         if v == nil {
23883                         } else if d.h.DeleteOnNilMapValue {
23884                                 delete(v, mk)
23885                         } else {
23886                                 v[mk] = 0
23887                         }
23888                         continue
23889                 }
23890                 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
23891                 if v != nil {
23892                         v[mk] = mv
23893                 }
23894         }
23895         dd.ReadMapEnd()
23896         d.depthDecr()
23897         return v, changed
23898 }
23899
23900 func (d *Decoder) fastpathDecMapUintInt16R(f *codecFnInfo, rv reflect.Value) {
23901         if rv.Kind() == reflect.Ptr {
23902                 vp := rv2i(rv).(*map[uint]int16)
23903                 v, changed := fastpathTV.DecMapUintInt16V(*vp, true, d)
23904                 if changed {
23905                         *vp = v
23906                 }
23907         } else {
23908                 fastpathTV.DecMapUintInt16V(rv2i(rv).(map[uint]int16), false, d)
23909         }
23910 }
23911 func (f fastpathT) DecMapUintInt16X(vp *map[uint]int16, d *Decoder) {
23912         v, changed := f.DecMapUintInt16V(*vp, true, d)
23913         if changed {
23914                 *vp = v
23915         }
23916 }
23917 func (_ fastpathT) DecMapUintInt16V(v map[uint]int16, canChange bool,
23918         d *Decoder) (_ map[uint]int16, changed bool) {
23919         dd, esep := d.d, d.hh.hasElemSeparators()
23920         containerLen := dd.ReadMapStart()
23921         if canChange && v == nil {
23922                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
23923                 v = make(map[uint]int16, xlen)
23924                 changed = true
23925         }
23926         if containerLen == 0 {
23927                 dd.ReadMapEnd()
23928                 return v, changed
23929         }
23930         d.depthIncr()
23931         var mk uint
23932         var mv int16
23933         hasLen := containerLen > 0
23934         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23935                 if esep {
23936                         dd.ReadMapElemKey()
23937                 }
23938                 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23939                 if esep {
23940                         dd.ReadMapElemValue()
23941                 }
23942                 if dd.TryDecodeAsNil() {
23943                         if v == nil {
23944                         } else if d.h.DeleteOnNilMapValue {
23945                                 delete(v, mk)
23946                         } else {
23947                                 v[mk] = 0
23948                         }
23949                         continue
23950                 }
23951                 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
23952                 if v != nil {
23953                         v[mk] = mv
23954                 }
23955         }
23956         dd.ReadMapEnd()
23957         d.depthDecr()
23958         return v, changed
23959 }
23960
23961 func (d *Decoder) fastpathDecMapUintInt32R(f *codecFnInfo, rv reflect.Value) {
23962         if rv.Kind() == reflect.Ptr {
23963                 vp := rv2i(rv).(*map[uint]int32)
23964                 v, changed := fastpathTV.DecMapUintInt32V(*vp, true, d)
23965                 if changed {
23966                         *vp = v
23967                 }
23968         } else {
23969                 fastpathTV.DecMapUintInt32V(rv2i(rv).(map[uint]int32), false, d)
23970         }
23971 }
23972 func (f fastpathT) DecMapUintInt32X(vp *map[uint]int32, d *Decoder) {
23973         v, changed := f.DecMapUintInt32V(*vp, true, d)
23974         if changed {
23975                 *vp = v
23976         }
23977 }
23978 func (_ fastpathT) DecMapUintInt32V(v map[uint]int32, canChange bool,
23979         d *Decoder) (_ map[uint]int32, changed bool) {
23980         dd, esep := d.d, d.hh.hasElemSeparators()
23981         containerLen := dd.ReadMapStart()
23982         if canChange && v == nil {
23983                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
23984                 v = make(map[uint]int32, xlen)
23985                 changed = true
23986         }
23987         if containerLen == 0 {
23988                 dd.ReadMapEnd()
23989                 return v, changed
23990         }
23991         d.depthIncr()
23992         var mk uint
23993         var mv int32
23994         hasLen := containerLen > 0
23995         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23996                 if esep {
23997                         dd.ReadMapElemKey()
23998                 }
23999                 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
24000                 if esep {
24001                         dd.ReadMapElemValue()
24002                 }
24003                 if dd.TryDecodeAsNil() {
24004                         if v == nil {
24005                         } else if d.h.DeleteOnNilMapValue {
24006                                 delete(v, mk)
24007                         } else {
24008                                 v[mk] = 0
24009                         }
24010                         continue
24011                 }
24012                 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
24013                 if v != nil {
24014                         v[mk] = mv
24015                 }
24016         }
24017         dd.ReadMapEnd()
24018         d.depthDecr()
24019         return v, changed
24020 }
24021
24022 func (d *Decoder) fastpathDecMapUintInt64R(f *codecFnInfo, rv reflect.Value) {
24023         if rv.Kind() == reflect.Ptr {
24024                 vp := rv2i(rv).(*map[uint]int64)
24025                 v, changed := fastpathTV.DecMapUintInt64V(*vp, true, d)
24026                 if changed {
24027                         *vp = v
24028                 }
24029         } else {
24030                 fastpathTV.DecMapUintInt64V(rv2i(rv).(map[uint]int64), false, d)
24031         }
24032 }
24033 func (f fastpathT) DecMapUintInt64X(vp *map[uint]int64, d *Decoder) {
24034         v, changed := f.DecMapUintInt64V(*vp, true, d)
24035         if changed {
24036                 *vp = v
24037         }
24038 }
24039 func (_ fastpathT) DecMapUintInt64V(v map[uint]int64, canChange bool,
24040         d *Decoder) (_ map[uint]int64, changed bool) {
24041         dd, esep := d.d, d.hh.hasElemSeparators()
24042         containerLen := dd.ReadMapStart()
24043         if canChange && v == nil {
24044                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
24045                 v = make(map[uint]int64, xlen)
24046                 changed = true
24047         }
24048         if containerLen == 0 {
24049                 dd.ReadMapEnd()
24050                 return v, changed
24051         }
24052         d.depthIncr()
24053         var mk uint
24054         var mv int64
24055         hasLen := containerLen > 0
24056         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24057                 if esep {
24058                         dd.ReadMapElemKey()
24059                 }
24060                 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
24061                 if esep {
24062                         dd.ReadMapElemValue()
24063                 }
24064                 if dd.TryDecodeAsNil() {
24065                         if v == nil {
24066                         } else if d.h.DeleteOnNilMapValue {
24067                                 delete(v, mk)
24068                         } else {
24069                                 v[mk] = 0
24070                         }
24071                         continue
24072                 }
24073                 mv = dd.DecodeInt64()
24074                 if v != nil {
24075                         v[mk] = mv
24076                 }
24077         }
24078         dd.ReadMapEnd()
24079         d.depthDecr()
24080         return v, changed
24081 }
24082
24083 func (d *Decoder) fastpathDecMapUintFloat32R(f *codecFnInfo, rv reflect.Value) {
24084         if rv.Kind() == reflect.Ptr {
24085                 vp := rv2i(rv).(*map[uint]float32)
24086                 v, changed := fastpathTV.DecMapUintFloat32V(*vp, true, d)
24087                 if changed {
24088                         *vp = v
24089                 }
24090         } else {
24091                 fastpathTV.DecMapUintFloat32V(rv2i(rv).(map[uint]float32), false, d)
24092         }
24093 }
24094 func (f fastpathT) DecMapUintFloat32X(vp *map[uint]float32, d *Decoder) {
24095         v, changed := f.DecMapUintFloat32V(*vp, true, d)
24096         if changed {
24097                 *vp = v
24098         }
24099 }
24100 func (_ fastpathT) DecMapUintFloat32V(v map[uint]float32, canChange bool,
24101         d *Decoder) (_ map[uint]float32, changed bool) {
24102         dd, esep := d.d, d.hh.hasElemSeparators()
24103         containerLen := dd.ReadMapStart()
24104         if canChange && v == nil {
24105                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
24106                 v = make(map[uint]float32, xlen)
24107                 changed = true
24108         }
24109         if containerLen == 0 {
24110                 dd.ReadMapEnd()
24111                 return v, changed
24112         }
24113         d.depthIncr()
24114         var mk uint
24115         var mv float32
24116         hasLen := containerLen > 0
24117         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24118                 if esep {
24119                         dd.ReadMapElemKey()
24120                 }
24121                 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
24122                 if esep {
24123                         dd.ReadMapElemValue()
24124                 }
24125                 if dd.TryDecodeAsNil() {
24126                         if v == nil {
24127                         } else if d.h.DeleteOnNilMapValue {
24128                                 delete(v, mk)
24129                         } else {
24130                                 v[mk] = 0
24131                         }
24132                         continue
24133                 }
24134                 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
24135                 if v != nil {
24136                         v[mk] = mv
24137                 }
24138         }
24139         dd.ReadMapEnd()
24140         d.depthDecr()
24141         return v, changed
24142 }
24143
24144 func (d *Decoder) fastpathDecMapUintFloat64R(f *codecFnInfo, rv reflect.Value) {
24145         if rv.Kind() == reflect.Ptr {
24146                 vp := rv2i(rv).(*map[uint]float64)
24147                 v, changed := fastpathTV.DecMapUintFloat64V(*vp, true, d)
24148                 if changed {
24149                         *vp = v
24150                 }
24151         } else {
24152                 fastpathTV.DecMapUintFloat64V(rv2i(rv).(map[uint]float64), false, d)
24153         }
24154 }
24155 func (f fastpathT) DecMapUintFloat64X(vp *map[uint]float64, d *Decoder) {
24156         v, changed := f.DecMapUintFloat64V(*vp, true, d)
24157         if changed {
24158                 *vp = v
24159         }
24160 }
24161 func (_ fastpathT) DecMapUintFloat64V(v map[uint]float64, canChange bool,
24162         d *Decoder) (_ map[uint]float64, changed bool) {
24163         dd, esep := d.d, d.hh.hasElemSeparators()
24164         containerLen := dd.ReadMapStart()
24165         if canChange && v == nil {
24166                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
24167                 v = make(map[uint]float64, xlen)
24168                 changed = true
24169         }
24170         if containerLen == 0 {
24171                 dd.ReadMapEnd()
24172                 return v, changed
24173         }
24174         d.depthIncr()
24175         var mk uint
24176         var mv float64
24177         hasLen := containerLen > 0
24178         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24179                 if esep {
24180                         dd.ReadMapElemKey()
24181                 }
24182                 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
24183                 if esep {
24184                         dd.ReadMapElemValue()
24185                 }
24186                 if dd.TryDecodeAsNil() {
24187                         if v == nil {
24188                         } else if d.h.DeleteOnNilMapValue {
24189                                 delete(v, mk)
24190                         } else {
24191                                 v[mk] = 0
24192                         }
24193                         continue
24194                 }
24195                 mv = dd.DecodeFloat64()
24196                 if v != nil {
24197                         v[mk] = mv
24198                 }
24199         }
24200         dd.ReadMapEnd()
24201         d.depthDecr()
24202         return v, changed
24203 }
24204
24205 func (d *Decoder) fastpathDecMapUintBoolR(f *codecFnInfo, rv reflect.Value) {
24206         if rv.Kind() == reflect.Ptr {
24207                 vp := rv2i(rv).(*map[uint]bool)
24208                 v, changed := fastpathTV.DecMapUintBoolV(*vp, true, d)
24209                 if changed {
24210                         *vp = v
24211                 }
24212         } else {
24213                 fastpathTV.DecMapUintBoolV(rv2i(rv).(map[uint]bool), false, d)
24214         }
24215 }
24216 func (f fastpathT) DecMapUintBoolX(vp *map[uint]bool, d *Decoder) {
24217         v, changed := f.DecMapUintBoolV(*vp, true, d)
24218         if changed {
24219                 *vp = v
24220         }
24221 }
24222 func (_ fastpathT) DecMapUintBoolV(v map[uint]bool, canChange bool,
24223         d *Decoder) (_ map[uint]bool, changed bool) {
24224         dd, esep := d.d, d.hh.hasElemSeparators()
24225         containerLen := dd.ReadMapStart()
24226         if canChange && v == nil {
24227                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
24228                 v = make(map[uint]bool, xlen)
24229                 changed = true
24230         }
24231         if containerLen == 0 {
24232                 dd.ReadMapEnd()
24233                 return v, changed
24234         }
24235         d.depthIncr()
24236         var mk uint
24237         var mv bool
24238         hasLen := containerLen > 0
24239         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24240                 if esep {
24241                         dd.ReadMapElemKey()
24242                 }
24243                 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
24244                 if esep {
24245                         dd.ReadMapElemValue()
24246                 }
24247                 if dd.TryDecodeAsNil() {
24248                         if v == nil {
24249                         } else if d.h.DeleteOnNilMapValue {
24250                                 delete(v, mk)
24251                         } else {
24252                                 v[mk] = false
24253                         }
24254                         continue
24255                 }
24256                 mv = dd.DecodeBool()
24257                 if v != nil {
24258                         v[mk] = mv
24259                 }
24260         }
24261         dd.ReadMapEnd()
24262         d.depthDecr()
24263         return v, changed
24264 }
24265
24266 func (d *Decoder) fastpathDecMapUint8IntfR(f *codecFnInfo, rv reflect.Value) {
24267         if rv.Kind() == reflect.Ptr {
24268                 vp := rv2i(rv).(*map[uint8]interface{})
24269                 v, changed := fastpathTV.DecMapUint8IntfV(*vp, true, d)
24270                 if changed {
24271                         *vp = v
24272                 }
24273         } else {
24274                 fastpathTV.DecMapUint8IntfV(rv2i(rv).(map[uint8]interface{}), false, d)
24275         }
24276 }
24277 func (f fastpathT) DecMapUint8IntfX(vp *map[uint8]interface{}, d *Decoder) {
24278         v, changed := f.DecMapUint8IntfV(*vp, true, d)
24279         if changed {
24280                 *vp = v
24281         }
24282 }
24283 func (_ fastpathT) DecMapUint8IntfV(v map[uint8]interface{}, canChange bool,
24284         d *Decoder) (_ map[uint8]interface{}, changed bool) {
24285         dd, esep := d.d, d.hh.hasElemSeparators()
24286         containerLen := dd.ReadMapStart()
24287         if canChange && v == nil {
24288                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
24289                 v = make(map[uint8]interface{}, xlen)
24290                 changed = true
24291         }
24292         if containerLen == 0 {
24293                 dd.ReadMapEnd()
24294                 return v, changed
24295         }
24296         d.depthIncr()
24297         mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
24298         var mk uint8
24299         var mv interface{}
24300         hasLen := containerLen > 0
24301         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24302                 if esep {
24303                         dd.ReadMapElemKey()
24304                 }
24305                 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24306                 if esep {
24307                         dd.ReadMapElemValue()
24308                 }
24309                 if dd.TryDecodeAsNil() {
24310                         if v == nil {
24311                         } else if d.h.DeleteOnNilMapValue {
24312                                 delete(v, mk)
24313                         } else {
24314                                 v[mk] = nil
24315                         }
24316                         continue
24317                 }
24318                 if mapGet {
24319                         mv = v[mk]
24320                 } else {
24321                         mv = nil
24322                 }
24323                 d.decode(&mv)
24324                 if v != nil {
24325                         v[mk] = mv
24326                 }
24327         }
24328         dd.ReadMapEnd()
24329         d.depthDecr()
24330         return v, changed
24331 }
24332
24333 func (d *Decoder) fastpathDecMapUint8StringR(f *codecFnInfo, rv reflect.Value) {
24334         if rv.Kind() == reflect.Ptr {
24335                 vp := rv2i(rv).(*map[uint8]string)
24336                 v, changed := fastpathTV.DecMapUint8StringV(*vp, true, d)
24337                 if changed {
24338                         *vp = v
24339                 }
24340         } else {
24341                 fastpathTV.DecMapUint8StringV(rv2i(rv).(map[uint8]string), false, d)
24342         }
24343 }
24344 func (f fastpathT) DecMapUint8StringX(vp *map[uint8]string, d *Decoder) {
24345         v, changed := f.DecMapUint8StringV(*vp, true, d)
24346         if changed {
24347                 *vp = v
24348         }
24349 }
24350 func (_ fastpathT) DecMapUint8StringV(v map[uint8]string, canChange bool,
24351         d *Decoder) (_ map[uint8]string, changed bool) {
24352         dd, esep := d.d, d.hh.hasElemSeparators()
24353         containerLen := dd.ReadMapStart()
24354         if canChange && v == nil {
24355                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
24356                 v = make(map[uint8]string, xlen)
24357                 changed = true
24358         }
24359         if containerLen == 0 {
24360                 dd.ReadMapEnd()
24361                 return v, changed
24362         }
24363         d.depthIncr()
24364         var mk uint8
24365         var mv string
24366         hasLen := containerLen > 0
24367         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24368                 if esep {
24369                         dd.ReadMapElemKey()
24370                 }
24371                 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24372                 if esep {
24373                         dd.ReadMapElemValue()
24374                 }
24375                 if dd.TryDecodeAsNil() {
24376                         if v == nil {
24377                         } else if d.h.DeleteOnNilMapValue {
24378                                 delete(v, mk)
24379                         } else {
24380                                 v[mk] = ""
24381                         }
24382                         continue
24383                 }
24384                 mv = dd.DecodeString()
24385                 if v != nil {
24386                         v[mk] = mv
24387                 }
24388         }
24389         dd.ReadMapEnd()
24390         d.depthDecr()
24391         return v, changed
24392 }
24393
24394 func (d *Decoder) fastpathDecMapUint8UintR(f *codecFnInfo, rv reflect.Value) {
24395         if rv.Kind() == reflect.Ptr {
24396                 vp := rv2i(rv).(*map[uint8]uint)
24397                 v, changed := fastpathTV.DecMapUint8UintV(*vp, true, d)
24398                 if changed {
24399                         *vp = v
24400                 }
24401         } else {
24402                 fastpathTV.DecMapUint8UintV(rv2i(rv).(map[uint8]uint), false, d)
24403         }
24404 }
24405 func (f fastpathT) DecMapUint8UintX(vp *map[uint8]uint, d *Decoder) {
24406         v, changed := f.DecMapUint8UintV(*vp, true, d)
24407         if changed {
24408                 *vp = v
24409         }
24410 }
24411 func (_ fastpathT) DecMapUint8UintV(v map[uint8]uint, canChange bool,
24412         d *Decoder) (_ map[uint8]uint, changed bool) {
24413         dd, esep := d.d, d.hh.hasElemSeparators()
24414         containerLen := dd.ReadMapStart()
24415         if canChange && v == nil {
24416                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
24417                 v = make(map[uint8]uint, xlen)
24418                 changed = true
24419         }
24420         if containerLen == 0 {
24421                 dd.ReadMapEnd()
24422                 return v, changed
24423         }
24424         d.depthIncr()
24425         var mk uint8
24426         var mv uint
24427         hasLen := containerLen > 0
24428         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24429                 if esep {
24430                         dd.ReadMapElemKey()
24431                 }
24432                 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24433                 if esep {
24434                         dd.ReadMapElemValue()
24435                 }
24436                 if dd.TryDecodeAsNil() {
24437                         if v == nil {
24438                         } else if d.h.DeleteOnNilMapValue {
24439                                 delete(v, mk)
24440                         } else {
24441                                 v[mk] = 0
24442                         }
24443                         continue
24444                 }
24445                 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
24446                 if v != nil {
24447                         v[mk] = mv
24448                 }
24449         }
24450         dd.ReadMapEnd()
24451         d.depthDecr()
24452         return v, changed
24453 }
24454
24455 func (d *Decoder) fastpathDecMapUint8Uint8R(f *codecFnInfo, rv reflect.Value) {
24456         if rv.Kind() == reflect.Ptr {
24457                 vp := rv2i(rv).(*map[uint8]uint8)
24458                 v, changed := fastpathTV.DecMapUint8Uint8V(*vp, true, d)
24459                 if changed {
24460                         *vp = v
24461                 }
24462         } else {
24463                 fastpathTV.DecMapUint8Uint8V(rv2i(rv).(map[uint8]uint8), false, d)
24464         }
24465 }
24466 func (f fastpathT) DecMapUint8Uint8X(vp *map[uint8]uint8, d *Decoder) {
24467         v, changed := f.DecMapUint8Uint8V(*vp, true, d)
24468         if changed {
24469                 *vp = v
24470         }
24471 }
24472 func (_ fastpathT) DecMapUint8Uint8V(v map[uint8]uint8, canChange bool,
24473         d *Decoder) (_ map[uint8]uint8, changed bool) {
24474         dd, esep := d.d, d.hh.hasElemSeparators()
24475         containerLen := dd.ReadMapStart()
24476         if canChange && v == nil {
24477                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
24478                 v = make(map[uint8]uint8, xlen)
24479                 changed = true
24480         }
24481         if containerLen == 0 {
24482                 dd.ReadMapEnd()
24483                 return v, changed
24484         }
24485         d.depthIncr()
24486         var mk uint8
24487         var mv uint8
24488         hasLen := containerLen > 0
24489         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24490                 if esep {
24491                         dd.ReadMapElemKey()
24492                 }
24493                 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24494                 if esep {
24495                         dd.ReadMapElemValue()
24496                 }
24497                 if dd.TryDecodeAsNil() {
24498                         if v == nil {
24499                         } else if d.h.DeleteOnNilMapValue {
24500                                 delete(v, mk)
24501                         } else {
24502                                 v[mk] = 0
24503                         }
24504                         continue
24505                 }
24506                 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24507                 if v != nil {
24508                         v[mk] = mv
24509                 }
24510         }
24511         dd.ReadMapEnd()
24512         d.depthDecr()
24513         return v, changed
24514 }
24515
24516 func (d *Decoder) fastpathDecMapUint8Uint16R(f *codecFnInfo, rv reflect.Value) {
24517         if rv.Kind() == reflect.Ptr {
24518                 vp := rv2i(rv).(*map[uint8]uint16)
24519                 v, changed := fastpathTV.DecMapUint8Uint16V(*vp, true, d)
24520                 if changed {
24521                         *vp = v
24522                 }
24523         } else {
24524                 fastpathTV.DecMapUint8Uint16V(rv2i(rv).(map[uint8]uint16), false, d)
24525         }
24526 }
24527 func (f fastpathT) DecMapUint8Uint16X(vp *map[uint8]uint16, d *Decoder) {
24528         v, changed := f.DecMapUint8Uint16V(*vp, true, d)
24529         if changed {
24530                 *vp = v
24531         }
24532 }
24533 func (_ fastpathT) DecMapUint8Uint16V(v map[uint8]uint16, canChange bool,
24534         d *Decoder) (_ map[uint8]uint16, changed bool) {
24535         dd, esep := d.d, d.hh.hasElemSeparators()
24536         containerLen := dd.ReadMapStart()
24537         if canChange && v == nil {
24538                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
24539                 v = make(map[uint8]uint16, xlen)
24540                 changed = true
24541         }
24542         if containerLen == 0 {
24543                 dd.ReadMapEnd()
24544                 return v, changed
24545         }
24546         d.depthIncr()
24547         var mk uint8
24548         var mv uint16
24549         hasLen := containerLen > 0
24550         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24551                 if esep {
24552                         dd.ReadMapElemKey()
24553                 }
24554                 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24555                 if esep {
24556                         dd.ReadMapElemValue()
24557                 }
24558                 if dd.TryDecodeAsNil() {
24559                         if v == nil {
24560                         } else if d.h.DeleteOnNilMapValue {
24561                                 delete(v, mk)
24562                         } else {
24563                                 v[mk] = 0
24564                         }
24565                         continue
24566                 }
24567                 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
24568                 if v != nil {
24569                         v[mk] = mv
24570                 }
24571         }
24572         dd.ReadMapEnd()
24573         d.depthDecr()
24574         return v, changed
24575 }
24576
24577 func (d *Decoder) fastpathDecMapUint8Uint32R(f *codecFnInfo, rv reflect.Value) {
24578         if rv.Kind() == reflect.Ptr {
24579                 vp := rv2i(rv).(*map[uint8]uint32)
24580                 v, changed := fastpathTV.DecMapUint8Uint32V(*vp, true, d)
24581                 if changed {
24582                         *vp = v
24583                 }
24584         } else {
24585                 fastpathTV.DecMapUint8Uint32V(rv2i(rv).(map[uint8]uint32), false, d)
24586         }
24587 }
24588 func (f fastpathT) DecMapUint8Uint32X(vp *map[uint8]uint32, d *Decoder) {
24589         v, changed := f.DecMapUint8Uint32V(*vp, true, d)
24590         if changed {
24591                 *vp = v
24592         }
24593 }
24594 func (_ fastpathT) DecMapUint8Uint32V(v map[uint8]uint32, canChange bool,
24595         d *Decoder) (_ map[uint8]uint32, changed bool) {
24596         dd, esep := d.d, d.hh.hasElemSeparators()
24597         containerLen := dd.ReadMapStart()
24598         if canChange && v == nil {
24599                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
24600                 v = make(map[uint8]uint32, xlen)
24601                 changed = true
24602         }
24603         if containerLen == 0 {
24604                 dd.ReadMapEnd()
24605                 return v, changed
24606         }
24607         d.depthIncr()
24608         var mk uint8
24609         var mv uint32
24610         hasLen := containerLen > 0
24611         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24612                 if esep {
24613                         dd.ReadMapElemKey()
24614                 }
24615                 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24616                 if esep {
24617                         dd.ReadMapElemValue()
24618                 }
24619                 if dd.TryDecodeAsNil() {
24620                         if v == nil {
24621                         } else if d.h.DeleteOnNilMapValue {
24622                                 delete(v, mk)
24623                         } else {
24624                                 v[mk] = 0
24625                         }
24626                         continue
24627                 }
24628                 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
24629                 if v != nil {
24630                         v[mk] = mv
24631                 }
24632         }
24633         dd.ReadMapEnd()
24634         d.depthDecr()
24635         return v, changed
24636 }
24637
24638 func (d *Decoder) fastpathDecMapUint8Uint64R(f *codecFnInfo, rv reflect.Value) {
24639         if rv.Kind() == reflect.Ptr {
24640                 vp := rv2i(rv).(*map[uint8]uint64)
24641                 v, changed := fastpathTV.DecMapUint8Uint64V(*vp, true, d)
24642                 if changed {
24643                         *vp = v
24644                 }
24645         } else {
24646                 fastpathTV.DecMapUint8Uint64V(rv2i(rv).(map[uint8]uint64), false, d)
24647         }
24648 }
24649 func (f fastpathT) DecMapUint8Uint64X(vp *map[uint8]uint64, d *Decoder) {
24650         v, changed := f.DecMapUint8Uint64V(*vp, true, d)
24651         if changed {
24652                 *vp = v
24653         }
24654 }
24655 func (_ fastpathT) DecMapUint8Uint64V(v map[uint8]uint64, canChange bool,
24656         d *Decoder) (_ map[uint8]uint64, changed bool) {
24657         dd, esep := d.d, d.hh.hasElemSeparators()
24658         containerLen := dd.ReadMapStart()
24659         if canChange && v == nil {
24660                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
24661                 v = make(map[uint8]uint64, xlen)
24662                 changed = true
24663         }
24664         if containerLen == 0 {
24665                 dd.ReadMapEnd()
24666                 return v, changed
24667         }
24668         d.depthIncr()
24669         var mk uint8
24670         var mv uint64
24671         hasLen := containerLen > 0
24672         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24673                 if esep {
24674                         dd.ReadMapElemKey()
24675                 }
24676                 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24677                 if esep {
24678                         dd.ReadMapElemValue()
24679                 }
24680                 if dd.TryDecodeAsNil() {
24681                         if v == nil {
24682                         } else if d.h.DeleteOnNilMapValue {
24683                                 delete(v, mk)
24684                         } else {
24685                                 v[mk] = 0
24686                         }
24687                         continue
24688                 }
24689                 mv = dd.DecodeUint64()
24690                 if v != nil {
24691                         v[mk] = mv
24692                 }
24693         }
24694         dd.ReadMapEnd()
24695         d.depthDecr()
24696         return v, changed
24697 }
24698
24699 func (d *Decoder) fastpathDecMapUint8UintptrR(f *codecFnInfo, rv reflect.Value) {
24700         if rv.Kind() == reflect.Ptr {
24701                 vp := rv2i(rv).(*map[uint8]uintptr)
24702                 v, changed := fastpathTV.DecMapUint8UintptrV(*vp, true, d)
24703                 if changed {
24704                         *vp = v
24705                 }
24706         } else {
24707                 fastpathTV.DecMapUint8UintptrV(rv2i(rv).(map[uint8]uintptr), false, d)
24708         }
24709 }
24710 func (f fastpathT) DecMapUint8UintptrX(vp *map[uint8]uintptr, d *Decoder) {
24711         v, changed := f.DecMapUint8UintptrV(*vp, true, d)
24712         if changed {
24713                 *vp = v
24714         }
24715 }
24716 func (_ fastpathT) DecMapUint8UintptrV(v map[uint8]uintptr, canChange bool,
24717         d *Decoder) (_ map[uint8]uintptr, changed bool) {
24718         dd, esep := d.d, d.hh.hasElemSeparators()
24719         containerLen := dd.ReadMapStart()
24720         if canChange && v == nil {
24721                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
24722                 v = make(map[uint8]uintptr, xlen)
24723                 changed = true
24724         }
24725         if containerLen == 0 {
24726                 dd.ReadMapEnd()
24727                 return v, changed
24728         }
24729         d.depthIncr()
24730         var mk uint8
24731         var mv uintptr
24732         hasLen := containerLen > 0
24733         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24734                 if esep {
24735                         dd.ReadMapElemKey()
24736                 }
24737                 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24738                 if esep {
24739                         dd.ReadMapElemValue()
24740                 }
24741                 if dd.TryDecodeAsNil() {
24742                         if v == nil {
24743                         } else if d.h.DeleteOnNilMapValue {
24744                                 delete(v, mk)
24745                         } else {
24746                                 v[mk] = 0
24747                         }
24748                         continue
24749                 }
24750                 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
24751                 if v != nil {
24752                         v[mk] = mv
24753                 }
24754         }
24755         dd.ReadMapEnd()
24756         d.depthDecr()
24757         return v, changed
24758 }
24759
24760 func (d *Decoder) fastpathDecMapUint8IntR(f *codecFnInfo, rv reflect.Value) {
24761         if rv.Kind() == reflect.Ptr {
24762                 vp := rv2i(rv).(*map[uint8]int)
24763                 v, changed := fastpathTV.DecMapUint8IntV(*vp, true, d)
24764                 if changed {
24765                         *vp = v
24766                 }
24767         } else {
24768                 fastpathTV.DecMapUint8IntV(rv2i(rv).(map[uint8]int), false, d)
24769         }
24770 }
24771 func (f fastpathT) DecMapUint8IntX(vp *map[uint8]int, d *Decoder) {
24772         v, changed := f.DecMapUint8IntV(*vp, true, d)
24773         if changed {
24774                 *vp = v
24775         }
24776 }
24777 func (_ fastpathT) DecMapUint8IntV(v map[uint8]int, canChange bool,
24778         d *Decoder) (_ map[uint8]int, changed bool) {
24779         dd, esep := d.d, d.hh.hasElemSeparators()
24780         containerLen := dd.ReadMapStart()
24781         if canChange && v == nil {
24782                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
24783                 v = make(map[uint8]int, xlen)
24784                 changed = true
24785         }
24786         if containerLen == 0 {
24787                 dd.ReadMapEnd()
24788                 return v, changed
24789         }
24790         d.depthIncr()
24791         var mk uint8
24792         var mv int
24793         hasLen := containerLen > 0
24794         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24795                 if esep {
24796                         dd.ReadMapElemKey()
24797                 }
24798                 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24799                 if esep {
24800                         dd.ReadMapElemValue()
24801                 }
24802                 if dd.TryDecodeAsNil() {
24803                         if v == nil {
24804                         } else if d.h.DeleteOnNilMapValue {
24805                                 delete(v, mk)
24806                         } else {
24807                                 v[mk] = 0
24808                         }
24809                         continue
24810                 }
24811                 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
24812                 if v != nil {
24813                         v[mk] = mv
24814                 }
24815         }
24816         dd.ReadMapEnd()
24817         d.depthDecr()
24818         return v, changed
24819 }
24820
24821 func (d *Decoder) fastpathDecMapUint8Int8R(f *codecFnInfo, rv reflect.Value) {
24822         if rv.Kind() == reflect.Ptr {
24823                 vp := rv2i(rv).(*map[uint8]int8)
24824                 v, changed := fastpathTV.DecMapUint8Int8V(*vp, true, d)
24825                 if changed {
24826                         *vp = v
24827                 }
24828         } else {
24829                 fastpathTV.DecMapUint8Int8V(rv2i(rv).(map[uint8]int8), false, d)
24830         }
24831 }
24832 func (f fastpathT) DecMapUint8Int8X(vp *map[uint8]int8, d *Decoder) {
24833         v, changed := f.DecMapUint8Int8V(*vp, true, d)
24834         if changed {
24835                 *vp = v
24836         }
24837 }
24838 func (_ fastpathT) DecMapUint8Int8V(v map[uint8]int8, canChange bool,
24839         d *Decoder) (_ map[uint8]int8, changed bool) {
24840         dd, esep := d.d, d.hh.hasElemSeparators()
24841         containerLen := dd.ReadMapStart()
24842         if canChange && v == nil {
24843                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
24844                 v = make(map[uint8]int8, xlen)
24845                 changed = true
24846         }
24847         if containerLen == 0 {
24848                 dd.ReadMapEnd()
24849                 return v, changed
24850         }
24851         d.depthIncr()
24852         var mk uint8
24853         var mv int8
24854         hasLen := containerLen > 0
24855         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24856                 if esep {
24857                         dd.ReadMapElemKey()
24858                 }
24859                 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24860                 if esep {
24861                         dd.ReadMapElemValue()
24862                 }
24863                 if dd.TryDecodeAsNil() {
24864                         if v == nil {
24865                         } else if d.h.DeleteOnNilMapValue {
24866                                 delete(v, mk)
24867                         } else {
24868                                 v[mk] = 0
24869                         }
24870                         continue
24871                 }
24872                 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
24873                 if v != nil {
24874                         v[mk] = mv
24875                 }
24876         }
24877         dd.ReadMapEnd()
24878         d.depthDecr()
24879         return v, changed
24880 }
24881
24882 func (d *Decoder) fastpathDecMapUint8Int16R(f *codecFnInfo, rv reflect.Value) {
24883         if rv.Kind() == reflect.Ptr {
24884                 vp := rv2i(rv).(*map[uint8]int16)
24885                 v, changed := fastpathTV.DecMapUint8Int16V(*vp, true, d)
24886                 if changed {
24887                         *vp = v
24888                 }
24889         } else {
24890                 fastpathTV.DecMapUint8Int16V(rv2i(rv).(map[uint8]int16), false, d)
24891         }
24892 }
24893 func (f fastpathT) DecMapUint8Int16X(vp *map[uint8]int16, d *Decoder) {
24894         v, changed := f.DecMapUint8Int16V(*vp, true, d)
24895         if changed {
24896                 *vp = v
24897         }
24898 }
24899 func (_ fastpathT) DecMapUint8Int16V(v map[uint8]int16, canChange bool,
24900         d *Decoder) (_ map[uint8]int16, changed bool) {
24901         dd, esep := d.d, d.hh.hasElemSeparators()
24902         containerLen := dd.ReadMapStart()
24903         if canChange && v == nil {
24904                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
24905                 v = make(map[uint8]int16, xlen)
24906                 changed = true
24907         }
24908         if containerLen == 0 {
24909                 dd.ReadMapEnd()
24910                 return v, changed
24911         }
24912         d.depthIncr()
24913         var mk uint8
24914         var mv int16
24915         hasLen := containerLen > 0
24916         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24917                 if esep {
24918                         dd.ReadMapElemKey()
24919                 }
24920                 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24921                 if esep {
24922                         dd.ReadMapElemValue()
24923                 }
24924                 if dd.TryDecodeAsNil() {
24925                         if v == nil {
24926                         } else if d.h.DeleteOnNilMapValue {
24927                                 delete(v, mk)
24928                         } else {
24929                                 v[mk] = 0
24930                         }
24931                         continue
24932                 }
24933                 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
24934                 if v != nil {
24935                         v[mk] = mv
24936                 }
24937         }
24938         dd.ReadMapEnd()
24939         d.depthDecr()
24940         return v, changed
24941 }
24942
24943 func (d *Decoder) fastpathDecMapUint8Int32R(f *codecFnInfo, rv reflect.Value) {
24944         if rv.Kind() == reflect.Ptr {
24945                 vp := rv2i(rv).(*map[uint8]int32)
24946                 v, changed := fastpathTV.DecMapUint8Int32V(*vp, true, d)
24947                 if changed {
24948                         *vp = v
24949                 }
24950         } else {
24951                 fastpathTV.DecMapUint8Int32V(rv2i(rv).(map[uint8]int32), false, d)
24952         }
24953 }
24954 func (f fastpathT) DecMapUint8Int32X(vp *map[uint8]int32, d *Decoder) {
24955         v, changed := f.DecMapUint8Int32V(*vp, true, d)
24956         if changed {
24957                 *vp = v
24958         }
24959 }
24960 func (_ fastpathT) DecMapUint8Int32V(v map[uint8]int32, canChange bool,
24961         d *Decoder) (_ map[uint8]int32, changed bool) {
24962         dd, esep := d.d, d.hh.hasElemSeparators()
24963         containerLen := dd.ReadMapStart()
24964         if canChange && v == nil {
24965                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
24966                 v = make(map[uint8]int32, xlen)
24967                 changed = true
24968         }
24969         if containerLen == 0 {
24970                 dd.ReadMapEnd()
24971                 return v, changed
24972         }
24973         d.depthIncr()
24974         var mk uint8
24975         var mv int32
24976         hasLen := containerLen > 0
24977         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24978                 if esep {
24979                         dd.ReadMapElemKey()
24980                 }
24981                 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24982                 if esep {
24983                         dd.ReadMapElemValue()
24984                 }
24985                 if dd.TryDecodeAsNil() {
24986                         if v == nil {
24987                         } else if d.h.DeleteOnNilMapValue {
24988                                 delete(v, mk)
24989                         } else {
24990                                 v[mk] = 0
24991                         }
24992                         continue
24993                 }
24994                 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
24995                 if v != nil {
24996                         v[mk] = mv
24997                 }
24998         }
24999         dd.ReadMapEnd()
25000         d.depthDecr()
25001         return v, changed
25002 }
25003
25004 func (d *Decoder) fastpathDecMapUint8Int64R(f *codecFnInfo, rv reflect.Value) {
25005         if rv.Kind() == reflect.Ptr {
25006                 vp := rv2i(rv).(*map[uint8]int64)
25007                 v, changed := fastpathTV.DecMapUint8Int64V(*vp, true, d)
25008                 if changed {
25009                         *vp = v
25010                 }
25011         } else {
25012                 fastpathTV.DecMapUint8Int64V(rv2i(rv).(map[uint8]int64), false, d)
25013         }
25014 }
25015 func (f fastpathT) DecMapUint8Int64X(vp *map[uint8]int64, d *Decoder) {
25016         v, changed := f.DecMapUint8Int64V(*vp, true, d)
25017         if changed {
25018                 *vp = v
25019         }
25020 }
25021 func (_ fastpathT) DecMapUint8Int64V(v map[uint8]int64, canChange bool,
25022         d *Decoder) (_ map[uint8]int64, changed bool) {
25023         dd, esep := d.d, d.hh.hasElemSeparators()
25024         containerLen := dd.ReadMapStart()
25025         if canChange && v == nil {
25026                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
25027                 v = make(map[uint8]int64, xlen)
25028                 changed = true
25029         }
25030         if containerLen == 0 {
25031                 dd.ReadMapEnd()
25032                 return v, changed
25033         }
25034         d.depthIncr()
25035         var mk uint8
25036         var mv int64
25037         hasLen := containerLen > 0
25038         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25039                 if esep {
25040                         dd.ReadMapElemKey()
25041                 }
25042                 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
25043                 if esep {
25044                         dd.ReadMapElemValue()
25045                 }
25046                 if dd.TryDecodeAsNil() {
25047                         if v == nil {
25048                         } else if d.h.DeleteOnNilMapValue {
25049                                 delete(v, mk)
25050                         } else {
25051                                 v[mk] = 0
25052                         }
25053                         continue
25054                 }
25055                 mv = dd.DecodeInt64()
25056                 if v != nil {
25057                         v[mk] = mv
25058                 }
25059         }
25060         dd.ReadMapEnd()
25061         d.depthDecr()
25062         return v, changed
25063 }
25064
25065 func (d *Decoder) fastpathDecMapUint8Float32R(f *codecFnInfo, rv reflect.Value) {
25066         if rv.Kind() == reflect.Ptr {
25067                 vp := rv2i(rv).(*map[uint8]float32)
25068                 v, changed := fastpathTV.DecMapUint8Float32V(*vp, true, d)
25069                 if changed {
25070                         *vp = v
25071                 }
25072         } else {
25073                 fastpathTV.DecMapUint8Float32V(rv2i(rv).(map[uint8]float32), false, d)
25074         }
25075 }
25076 func (f fastpathT) DecMapUint8Float32X(vp *map[uint8]float32, d *Decoder) {
25077         v, changed := f.DecMapUint8Float32V(*vp, true, d)
25078         if changed {
25079                 *vp = v
25080         }
25081 }
25082 func (_ fastpathT) DecMapUint8Float32V(v map[uint8]float32, canChange bool,
25083         d *Decoder) (_ map[uint8]float32, changed bool) {
25084         dd, esep := d.d, d.hh.hasElemSeparators()
25085         containerLen := dd.ReadMapStart()
25086         if canChange && v == nil {
25087                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
25088                 v = make(map[uint8]float32, xlen)
25089                 changed = true
25090         }
25091         if containerLen == 0 {
25092                 dd.ReadMapEnd()
25093                 return v, changed
25094         }
25095         d.depthIncr()
25096         var mk uint8
25097         var mv float32
25098         hasLen := containerLen > 0
25099         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25100                 if esep {
25101                         dd.ReadMapElemKey()
25102                 }
25103                 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
25104                 if esep {
25105                         dd.ReadMapElemValue()
25106                 }
25107                 if dd.TryDecodeAsNil() {
25108                         if v == nil {
25109                         } else if d.h.DeleteOnNilMapValue {
25110                                 delete(v, mk)
25111                         } else {
25112                                 v[mk] = 0
25113                         }
25114                         continue
25115                 }
25116                 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
25117                 if v != nil {
25118                         v[mk] = mv
25119                 }
25120         }
25121         dd.ReadMapEnd()
25122         d.depthDecr()
25123         return v, changed
25124 }
25125
25126 func (d *Decoder) fastpathDecMapUint8Float64R(f *codecFnInfo, rv reflect.Value) {
25127         if rv.Kind() == reflect.Ptr {
25128                 vp := rv2i(rv).(*map[uint8]float64)
25129                 v, changed := fastpathTV.DecMapUint8Float64V(*vp, true, d)
25130                 if changed {
25131                         *vp = v
25132                 }
25133         } else {
25134                 fastpathTV.DecMapUint8Float64V(rv2i(rv).(map[uint8]float64), false, d)
25135         }
25136 }
25137 func (f fastpathT) DecMapUint8Float64X(vp *map[uint8]float64, d *Decoder) {
25138         v, changed := f.DecMapUint8Float64V(*vp, true, d)
25139         if changed {
25140                 *vp = v
25141         }
25142 }
25143 func (_ fastpathT) DecMapUint8Float64V(v map[uint8]float64, canChange bool,
25144         d *Decoder) (_ map[uint8]float64, changed bool) {
25145         dd, esep := d.d, d.hh.hasElemSeparators()
25146         containerLen := dd.ReadMapStart()
25147         if canChange && v == nil {
25148                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
25149                 v = make(map[uint8]float64, xlen)
25150                 changed = true
25151         }
25152         if containerLen == 0 {
25153                 dd.ReadMapEnd()
25154                 return v, changed
25155         }
25156         d.depthIncr()
25157         var mk uint8
25158         var mv float64
25159         hasLen := containerLen > 0
25160         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25161                 if esep {
25162                         dd.ReadMapElemKey()
25163                 }
25164                 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
25165                 if esep {
25166                         dd.ReadMapElemValue()
25167                 }
25168                 if dd.TryDecodeAsNil() {
25169                         if v == nil {
25170                         } else if d.h.DeleteOnNilMapValue {
25171                                 delete(v, mk)
25172                         } else {
25173                                 v[mk] = 0
25174                         }
25175                         continue
25176                 }
25177                 mv = dd.DecodeFloat64()
25178                 if v != nil {
25179                         v[mk] = mv
25180                 }
25181         }
25182         dd.ReadMapEnd()
25183         d.depthDecr()
25184         return v, changed
25185 }
25186
25187 func (d *Decoder) fastpathDecMapUint8BoolR(f *codecFnInfo, rv reflect.Value) {
25188         if rv.Kind() == reflect.Ptr {
25189                 vp := rv2i(rv).(*map[uint8]bool)
25190                 v, changed := fastpathTV.DecMapUint8BoolV(*vp, true, d)
25191                 if changed {
25192                         *vp = v
25193                 }
25194         } else {
25195                 fastpathTV.DecMapUint8BoolV(rv2i(rv).(map[uint8]bool), false, d)
25196         }
25197 }
25198 func (f fastpathT) DecMapUint8BoolX(vp *map[uint8]bool, d *Decoder) {
25199         v, changed := f.DecMapUint8BoolV(*vp, true, d)
25200         if changed {
25201                 *vp = v
25202         }
25203 }
25204 func (_ fastpathT) DecMapUint8BoolV(v map[uint8]bool, canChange bool,
25205         d *Decoder) (_ map[uint8]bool, changed bool) {
25206         dd, esep := d.d, d.hh.hasElemSeparators()
25207         containerLen := dd.ReadMapStart()
25208         if canChange && v == nil {
25209                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
25210                 v = make(map[uint8]bool, xlen)
25211                 changed = true
25212         }
25213         if containerLen == 0 {
25214                 dd.ReadMapEnd()
25215                 return v, changed
25216         }
25217         d.depthIncr()
25218         var mk uint8
25219         var mv bool
25220         hasLen := containerLen > 0
25221         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25222                 if esep {
25223                         dd.ReadMapElemKey()
25224                 }
25225                 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
25226                 if esep {
25227                         dd.ReadMapElemValue()
25228                 }
25229                 if dd.TryDecodeAsNil() {
25230                         if v == nil {
25231                         } else if d.h.DeleteOnNilMapValue {
25232                                 delete(v, mk)
25233                         } else {
25234                                 v[mk] = false
25235                         }
25236                         continue
25237                 }
25238                 mv = dd.DecodeBool()
25239                 if v != nil {
25240                         v[mk] = mv
25241                 }
25242         }
25243         dd.ReadMapEnd()
25244         d.depthDecr()
25245         return v, changed
25246 }
25247
25248 func (d *Decoder) fastpathDecMapUint16IntfR(f *codecFnInfo, rv reflect.Value) {
25249         if rv.Kind() == reflect.Ptr {
25250                 vp := rv2i(rv).(*map[uint16]interface{})
25251                 v, changed := fastpathTV.DecMapUint16IntfV(*vp, true, d)
25252                 if changed {
25253                         *vp = v
25254                 }
25255         } else {
25256                 fastpathTV.DecMapUint16IntfV(rv2i(rv).(map[uint16]interface{}), false, d)
25257         }
25258 }
25259 func (f fastpathT) DecMapUint16IntfX(vp *map[uint16]interface{}, d *Decoder) {
25260         v, changed := f.DecMapUint16IntfV(*vp, true, d)
25261         if changed {
25262                 *vp = v
25263         }
25264 }
25265 func (_ fastpathT) DecMapUint16IntfV(v map[uint16]interface{}, canChange bool,
25266         d *Decoder) (_ map[uint16]interface{}, changed bool) {
25267         dd, esep := d.d, d.hh.hasElemSeparators()
25268         containerLen := dd.ReadMapStart()
25269         if canChange && v == nil {
25270                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
25271                 v = make(map[uint16]interface{}, xlen)
25272                 changed = true
25273         }
25274         if containerLen == 0 {
25275                 dd.ReadMapEnd()
25276                 return v, changed
25277         }
25278         d.depthIncr()
25279         mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
25280         var mk uint16
25281         var mv interface{}
25282         hasLen := containerLen > 0
25283         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25284                 if esep {
25285                         dd.ReadMapElemKey()
25286                 }
25287                 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25288                 if esep {
25289                         dd.ReadMapElemValue()
25290                 }
25291                 if dd.TryDecodeAsNil() {
25292                         if v == nil {
25293                         } else if d.h.DeleteOnNilMapValue {
25294                                 delete(v, mk)
25295                         } else {
25296                                 v[mk] = nil
25297                         }
25298                         continue
25299                 }
25300                 if mapGet {
25301                         mv = v[mk]
25302                 } else {
25303                         mv = nil
25304                 }
25305                 d.decode(&mv)
25306                 if v != nil {
25307                         v[mk] = mv
25308                 }
25309         }
25310         dd.ReadMapEnd()
25311         d.depthDecr()
25312         return v, changed
25313 }
25314
25315 func (d *Decoder) fastpathDecMapUint16StringR(f *codecFnInfo, rv reflect.Value) {
25316         if rv.Kind() == reflect.Ptr {
25317                 vp := rv2i(rv).(*map[uint16]string)
25318                 v, changed := fastpathTV.DecMapUint16StringV(*vp, true, d)
25319                 if changed {
25320                         *vp = v
25321                 }
25322         } else {
25323                 fastpathTV.DecMapUint16StringV(rv2i(rv).(map[uint16]string), false, d)
25324         }
25325 }
25326 func (f fastpathT) DecMapUint16StringX(vp *map[uint16]string, d *Decoder) {
25327         v, changed := f.DecMapUint16StringV(*vp, true, d)
25328         if changed {
25329                 *vp = v
25330         }
25331 }
25332 func (_ fastpathT) DecMapUint16StringV(v map[uint16]string, canChange bool,
25333         d *Decoder) (_ map[uint16]string, changed bool) {
25334         dd, esep := d.d, d.hh.hasElemSeparators()
25335         containerLen := dd.ReadMapStart()
25336         if canChange && v == nil {
25337                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
25338                 v = make(map[uint16]string, xlen)
25339                 changed = true
25340         }
25341         if containerLen == 0 {
25342                 dd.ReadMapEnd()
25343                 return v, changed
25344         }
25345         d.depthIncr()
25346         var mk uint16
25347         var mv string
25348         hasLen := containerLen > 0
25349         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25350                 if esep {
25351                         dd.ReadMapElemKey()
25352                 }
25353                 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25354                 if esep {
25355                         dd.ReadMapElemValue()
25356                 }
25357                 if dd.TryDecodeAsNil() {
25358                         if v == nil {
25359                         } else if d.h.DeleteOnNilMapValue {
25360                                 delete(v, mk)
25361                         } else {
25362                                 v[mk] = ""
25363                         }
25364                         continue
25365                 }
25366                 mv = dd.DecodeString()
25367                 if v != nil {
25368                         v[mk] = mv
25369                 }
25370         }
25371         dd.ReadMapEnd()
25372         d.depthDecr()
25373         return v, changed
25374 }
25375
25376 func (d *Decoder) fastpathDecMapUint16UintR(f *codecFnInfo, rv reflect.Value) {
25377         if rv.Kind() == reflect.Ptr {
25378                 vp := rv2i(rv).(*map[uint16]uint)
25379                 v, changed := fastpathTV.DecMapUint16UintV(*vp, true, d)
25380                 if changed {
25381                         *vp = v
25382                 }
25383         } else {
25384                 fastpathTV.DecMapUint16UintV(rv2i(rv).(map[uint16]uint), false, d)
25385         }
25386 }
25387 func (f fastpathT) DecMapUint16UintX(vp *map[uint16]uint, d *Decoder) {
25388         v, changed := f.DecMapUint16UintV(*vp, true, d)
25389         if changed {
25390                 *vp = v
25391         }
25392 }
25393 func (_ fastpathT) DecMapUint16UintV(v map[uint16]uint, canChange bool,
25394         d *Decoder) (_ map[uint16]uint, changed bool) {
25395         dd, esep := d.d, d.hh.hasElemSeparators()
25396         containerLen := dd.ReadMapStart()
25397         if canChange && v == nil {
25398                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
25399                 v = make(map[uint16]uint, xlen)
25400                 changed = true
25401         }
25402         if containerLen == 0 {
25403                 dd.ReadMapEnd()
25404                 return v, changed
25405         }
25406         d.depthIncr()
25407         var mk uint16
25408         var mv uint
25409         hasLen := containerLen > 0
25410         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25411                 if esep {
25412                         dd.ReadMapElemKey()
25413                 }
25414                 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25415                 if esep {
25416                         dd.ReadMapElemValue()
25417                 }
25418                 if dd.TryDecodeAsNil() {
25419                         if v == nil {
25420                         } else if d.h.DeleteOnNilMapValue {
25421                                 delete(v, mk)
25422                         } else {
25423                                 v[mk] = 0
25424                         }
25425                         continue
25426                 }
25427                 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
25428                 if v != nil {
25429                         v[mk] = mv
25430                 }
25431         }
25432         dd.ReadMapEnd()
25433         d.depthDecr()
25434         return v, changed
25435 }
25436
25437 func (d *Decoder) fastpathDecMapUint16Uint8R(f *codecFnInfo, rv reflect.Value) {
25438         if rv.Kind() == reflect.Ptr {
25439                 vp := rv2i(rv).(*map[uint16]uint8)
25440                 v, changed := fastpathTV.DecMapUint16Uint8V(*vp, true, d)
25441                 if changed {
25442                         *vp = v
25443                 }
25444         } else {
25445                 fastpathTV.DecMapUint16Uint8V(rv2i(rv).(map[uint16]uint8), false, d)
25446         }
25447 }
25448 func (f fastpathT) DecMapUint16Uint8X(vp *map[uint16]uint8, d *Decoder) {
25449         v, changed := f.DecMapUint16Uint8V(*vp, true, d)
25450         if changed {
25451                 *vp = v
25452         }
25453 }
25454 func (_ fastpathT) DecMapUint16Uint8V(v map[uint16]uint8, canChange bool,
25455         d *Decoder) (_ map[uint16]uint8, changed bool) {
25456         dd, esep := d.d, d.hh.hasElemSeparators()
25457         containerLen := dd.ReadMapStart()
25458         if canChange && v == nil {
25459                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
25460                 v = make(map[uint16]uint8, xlen)
25461                 changed = true
25462         }
25463         if containerLen == 0 {
25464                 dd.ReadMapEnd()
25465                 return v, changed
25466         }
25467         d.depthIncr()
25468         var mk uint16
25469         var mv uint8
25470         hasLen := containerLen > 0
25471         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25472                 if esep {
25473                         dd.ReadMapElemKey()
25474                 }
25475                 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25476                 if esep {
25477                         dd.ReadMapElemValue()
25478                 }
25479                 if dd.TryDecodeAsNil() {
25480                         if v == nil {
25481                         } else if d.h.DeleteOnNilMapValue {
25482                                 delete(v, mk)
25483                         } else {
25484                                 v[mk] = 0
25485                         }
25486                         continue
25487                 }
25488                 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
25489                 if v != nil {
25490                         v[mk] = mv
25491                 }
25492         }
25493         dd.ReadMapEnd()
25494         d.depthDecr()
25495         return v, changed
25496 }
25497
25498 func (d *Decoder) fastpathDecMapUint16Uint16R(f *codecFnInfo, rv reflect.Value) {
25499         if rv.Kind() == reflect.Ptr {
25500                 vp := rv2i(rv).(*map[uint16]uint16)
25501                 v, changed := fastpathTV.DecMapUint16Uint16V(*vp, true, d)
25502                 if changed {
25503                         *vp = v
25504                 }
25505         } else {
25506                 fastpathTV.DecMapUint16Uint16V(rv2i(rv).(map[uint16]uint16), false, d)
25507         }
25508 }
25509 func (f fastpathT) DecMapUint16Uint16X(vp *map[uint16]uint16, d *Decoder) {
25510         v, changed := f.DecMapUint16Uint16V(*vp, true, d)
25511         if changed {
25512                 *vp = v
25513         }
25514 }
25515 func (_ fastpathT) DecMapUint16Uint16V(v map[uint16]uint16, canChange bool,
25516         d *Decoder) (_ map[uint16]uint16, changed bool) {
25517         dd, esep := d.d, d.hh.hasElemSeparators()
25518         containerLen := dd.ReadMapStart()
25519         if canChange && v == nil {
25520                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 4)
25521                 v = make(map[uint16]uint16, xlen)
25522                 changed = true
25523         }
25524         if containerLen == 0 {
25525                 dd.ReadMapEnd()
25526                 return v, changed
25527         }
25528         d.depthIncr()
25529         var mk uint16
25530         var mv uint16
25531         hasLen := containerLen > 0
25532         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25533                 if esep {
25534                         dd.ReadMapElemKey()
25535                 }
25536                 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25537                 if esep {
25538                         dd.ReadMapElemValue()
25539                 }
25540                 if dd.TryDecodeAsNil() {
25541                         if v == nil {
25542                         } else if d.h.DeleteOnNilMapValue {
25543                                 delete(v, mk)
25544                         } else {
25545                                 v[mk] = 0
25546                         }
25547                         continue
25548                 }
25549                 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25550                 if v != nil {
25551                         v[mk] = mv
25552                 }
25553         }
25554         dd.ReadMapEnd()
25555         d.depthDecr()
25556         return v, changed
25557 }
25558
25559 func (d *Decoder) fastpathDecMapUint16Uint32R(f *codecFnInfo, rv reflect.Value) {
25560         if rv.Kind() == reflect.Ptr {
25561                 vp := rv2i(rv).(*map[uint16]uint32)
25562                 v, changed := fastpathTV.DecMapUint16Uint32V(*vp, true, d)
25563                 if changed {
25564                         *vp = v
25565                 }
25566         } else {
25567                 fastpathTV.DecMapUint16Uint32V(rv2i(rv).(map[uint16]uint32), false, d)
25568         }
25569 }
25570 func (f fastpathT) DecMapUint16Uint32X(vp *map[uint16]uint32, d *Decoder) {
25571         v, changed := f.DecMapUint16Uint32V(*vp, true, d)
25572         if changed {
25573                 *vp = v
25574         }
25575 }
25576 func (_ fastpathT) DecMapUint16Uint32V(v map[uint16]uint32, canChange bool,
25577         d *Decoder) (_ map[uint16]uint32, changed bool) {
25578         dd, esep := d.d, d.hh.hasElemSeparators()
25579         containerLen := dd.ReadMapStart()
25580         if canChange && v == nil {
25581                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
25582                 v = make(map[uint16]uint32, xlen)
25583                 changed = true
25584         }
25585         if containerLen == 0 {
25586                 dd.ReadMapEnd()
25587                 return v, changed
25588         }
25589         d.depthIncr()
25590         var mk uint16
25591         var mv uint32
25592         hasLen := containerLen > 0
25593         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25594                 if esep {
25595                         dd.ReadMapElemKey()
25596                 }
25597                 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25598                 if esep {
25599                         dd.ReadMapElemValue()
25600                 }
25601                 if dd.TryDecodeAsNil() {
25602                         if v == nil {
25603                         } else if d.h.DeleteOnNilMapValue {
25604                                 delete(v, mk)
25605                         } else {
25606                                 v[mk] = 0
25607                         }
25608                         continue
25609                 }
25610                 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
25611                 if v != nil {
25612                         v[mk] = mv
25613                 }
25614         }
25615         dd.ReadMapEnd()
25616         d.depthDecr()
25617         return v, changed
25618 }
25619
25620 func (d *Decoder) fastpathDecMapUint16Uint64R(f *codecFnInfo, rv reflect.Value) {
25621         if rv.Kind() == reflect.Ptr {
25622                 vp := rv2i(rv).(*map[uint16]uint64)
25623                 v, changed := fastpathTV.DecMapUint16Uint64V(*vp, true, d)
25624                 if changed {
25625                         *vp = v
25626                 }
25627         } else {
25628                 fastpathTV.DecMapUint16Uint64V(rv2i(rv).(map[uint16]uint64), false, d)
25629         }
25630 }
25631 func (f fastpathT) DecMapUint16Uint64X(vp *map[uint16]uint64, d *Decoder) {
25632         v, changed := f.DecMapUint16Uint64V(*vp, true, d)
25633         if changed {
25634                 *vp = v
25635         }
25636 }
25637 func (_ fastpathT) DecMapUint16Uint64V(v map[uint16]uint64, canChange bool,
25638         d *Decoder) (_ map[uint16]uint64, changed bool) {
25639         dd, esep := d.d, d.hh.hasElemSeparators()
25640         containerLen := dd.ReadMapStart()
25641         if canChange && v == nil {
25642                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
25643                 v = make(map[uint16]uint64, xlen)
25644                 changed = true
25645         }
25646         if containerLen == 0 {
25647                 dd.ReadMapEnd()
25648                 return v, changed
25649         }
25650         d.depthIncr()
25651         var mk uint16
25652         var mv uint64
25653         hasLen := containerLen > 0
25654         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25655                 if esep {
25656                         dd.ReadMapElemKey()
25657                 }
25658                 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25659                 if esep {
25660                         dd.ReadMapElemValue()
25661                 }
25662                 if dd.TryDecodeAsNil() {
25663                         if v == nil {
25664                         } else if d.h.DeleteOnNilMapValue {
25665                                 delete(v, mk)
25666                         } else {
25667                                 v[mk] = 0
25668                         }
25669                         continue
25670                 }
25671                 mv = dd.DecodeUint64()
25672                 if v != nil {
25673                         v[mk] = mv
25674                 }
25675         }
25676         dd.ReadMapEnd()
25677         d.depthDecr()
25678         return v, changed
25679 }
25680
25681 func (d *Decoder) fastpathDecMapUint16UintptrR(f *codecFnInfo, rv reflect.Value) {
25682         if rv.Kind() == reflect.Ptr {
25683                 vp := rv2i(rv).(*map[uint16]uintptr)
25684                 v, changed := fastpathTV.DecMapUint16UintptrV(*vp, true, d)
25685                 if changed {
25686                         *vp = v
25687                 }
25688         } else {
25689                 fastpathTV.DecMapUint16UintptrV(rv2i(rv).(map[uint16]uintptr), false, d)
25690         }
25691 }
25692 func (f fastpathT) DecMapUint16UintptrX(vp *map[uint16]uintptr, d *Decoder) {
25693         v, changed := f.DecMapUint16UintptrV(*vp, true, d)
25694         if changed {
25695                 *vp = v
25696         }
25697 }
25698 func (_ fastpathT) DecMapUint16UintptrV(v map[uint16]uintptr, canChange bool,
25699         d *Decoder) (_ map[uint16]uintptr, changed bool) {
25700         dd, esep := d.d, d.hh.hasElemSeparators()
25701         containerLen := dd.ReadMapStart()
25702         if canChange && v == nil {
25703                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
25704                 v = make(map[uint16]uintptr, xlen)
25705                 changed = true
25706         }
25707         if containerLen == 0 {
25708                 dd.ReadMapEnd()
25709                 return v, changed
25710         }
25711         d.depthIncr()
25712         var mk uint16
25713         var mv uintptr
25714         hasLen := containerLen > 0
25715         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25716                 if esep {
25717                         dd.ReadMapElemKey()
25718                 }
25719                 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25720                 if esep {
25721                         dd.ReadMapElemValue()
25722                 }
25723                 if dd.TryDecodeAsNil() {
25724                         if v == nil {
25725                         } else if d.h.DeleteOnNilMapValue {
25726                                 delete(v, mk)
25727                         } else {
25728                                 v[mk] = 0
25729                         }
25730                         continue
25731                 }
25732                 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
25733                 if v != nil {
25734                         v[mk] = mv
25735                 }
25736         }
25737         dd.ReadMapEnd()
25738         d.depthDecr()
25739         return v, changed
25740 }
25741
25742 func (d *Decoder) fastpathDecMapUint16IntR(f *codecFnInfo, rv reflect.Value) {
25743         if rv.Kind() == reflect.Ptr {
25744                 vp := rv2i(rv).(*map[uint16]int)
25745                 v, changed := fastpathTV.DecMapUint16IntV(*vp, true, d)
25746                 if changed {
25747                         *vp = v
25748                 }
25749         } else {
25750                 fastpathTV.DecMapUint16IntV(rv2i(rv).(map[uint16]int), false, d)
25751         }
25752 }
25753 func (f fastpathT) DecMapUint16IntX(vp *map[uint16]int, d *Decoder) {
25754         v, changed := f.DecMapUint16IntV(*vp, true, d)
25755         if changed {
25756                 *vp = v
25757         }
25758 }
25759 func (_ fastpathT) DecMapUint16IntV(v map[uint16]int, canChange bool,
25760         d *Decoder) (_ map[uint16]int, changed bool) {
25761         dd, esep := d.d, d.hh.hasElemSeparators()
25762         containerLen := dd.ReadMapStart()
25763         if canChange && v == nil {
25764                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
25765                 v = make(map[uint16]int, xlen)
25766                 changed = true
25767         }
25768         if containerLen == 0 {
25769                 dd.ReadMapEnd()
25770                 return v, changed
25771         }
25772         d.depthIncr()
25773         var mk uint16
25774         var mv int
25775         hasLen := containerLen > 0
25776         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25777                 if esep {
25778                         dd.ReadMapElemKey()
25779                 }
25780                 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25781                 if esep {
25782                         dd.ReadMapElemValue()
25783                 }
25784                 if dd.TryDecodeAsNil() {
25785                         if v == nil {
25786                         } else if d.h.DeleteOnNilMapValue {
25787                                 delete(v, mk)
25788                         } else {
25789                                 v[mk] = 0
25790                         }
25791                         continue
25792                 }
25793                 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
25794                 if v != nil {
25795                         v[mk] = mv
25796                 }
25797         }
25798         dd.ReadMapEnd()
25799         d.depthDecr()
25800         return v, changed
25801 }
25802
25803 func (d *Decoder) fastpathDecMapUint16Int8R(f *codecFnInfo, rv reflect.Value) {
25804         if rv.Kind() == reflect.Ptr {
25805                 vp := rv2i(rv).(*map[uint16]int8)
25806                 v, changed := fastpathTV.DecMapUint16Int8V(*vp, true, d)
25807                 if changed {
25808                         *vp = v
25809                 }
25810         } else {
25811                 fastpathTV.DecMapUint16Int8V(rv2i(rv).(map[uint16]int8), false, d)
25812         }
25813 }
25814 func (f fastpathT) DecMapUint16Int8X(vp *map[uint16]int8, d *Decoder) {
25815         v, changed := f.DecMapUint16Int8V(*vp, true, d)
25816         if changed {
25817                 *vp = v
25818         }
25819 }
25820 func (_ fastpathT) DecMapUint16Int8V(v map[uint16]int8, canChange bool,
25821         d *Decoder) (_ map[uint16]int8, changed bool) {
25822         dd, esep := d.d, d.hh.hasElemSeparators()
25823         containerLen := dd.ReadMapStart()
25824         if canChange && v == nil {
25825                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
25826                 v = make(map[uint16]int8, xlen)
25827                 changed = true
25828         }
25829         if containerLen == 0 {
25830                 dd.ReadMapEnd()
25831                 return v, changed
25832         }
25833         d.depthIncr()
25834         var mk uint16
25835         var mv int8
25836         hasLen := containerLen > 0
25837         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25838                 if esep {
25839                         dd.ReadMapElemKey()
25840                 }
25841                 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25842                 if esep {
25843                         dd.ReadMapElemValue()
25844                 }
25845                 if dd.TryDecodeAsNil() {
25846                         if v == nil {
25847                         } else if d.h.DeleteOnNilMapValue {
25848                                 delete(v, mk)
25849                         } else {
25850                                 v[mk] = 0
25851                         }
25852                         continue
25853                 }
25854                 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
25855                 if v != nil {
25856                         v[mk] = mv
25857                 }
25858         }
25859         dd.ReadMapEnd()
25860         d.depthDecr()
25861         return v, changed
25862 }
25863
25864 func (d *Decoder) fastpathDecMapUint16Int16R(f *codecFnInfo, rv reflect.Value) {
25865         if rv.Kind() == reflect.Ptr {
25866                 vp := rv2i(rv).(*map[uint16]int16)
25867                 v, changed := fastpathTV.DecMapUint16Int16V(*vp, true, d)
25868                 if changed {
25869                         *vp = v
25870                 }
25871         } else {
25872                 fastpathTV.DecMapUint16Int16V(rv2i(rv).(map[uint16]int16), false, d)
25873         }
25874 }
25875 func (f fastpathT) DecMapUint16Int16X(vp *map[uint16]int16, d *Decoder) {
25876         v, changed := f.DecMapUint16Int16V(*vp, true, d)
25877         if changed {
25878                 *vp = v
25879         }
25880 }
25881 func (_ fastpathT) DecMapUint16Int16V(v map[uint16]int16, canChange bool,
25882         d *Decoder) (_ map[uint16]int16, changed bool) {
25883         dd, esep := d.d, d.hh.hasElemSeparators()
25884         containerLen := dd.ReadMapStart()
25885         if canChange && v == nil {
25886                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 4)
25887                 v = make(map[uint16]int16, xlen)
25888                 changed = true
25889         }
25890         if containerLen == 0 {
25891                 dd.ReadMapEnd()
25892                 return v, changed
25893         }
25894         d.depthIncr()
25895         var mk uint16
25896         var mv int16
25897         hasLen := containerLen > 0
25898         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25899                 if esep {
25900                         dd.ReadMapElemKey()
25901                 }
25902                 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25903                 if esep {
25904                         dd.ReadMapElemValue()
25905                 }
25906                 if dd.TryDecodeAsNil() {
25907                         if v == nil {
25908                         } else if d.h.DeleteOnNilMapValue {
25909                                 delete(v, mk)
25910                         } else {
25911                                 v[mk] = 0
25912                         }
25913                         continue
25914                 }
25915                 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
25916                 if v != nil {
25917                         v[mk] = mv
25918                 }
25919         }
25920         dd.ReadMapEnd()
25921         d.depthDecr()
25922         return v, changed
25923 }
25924
25925 func (d *Decoder) fastpathDecMapUint16Int32R(f *codecFnInfo, rv reflect.Value) {
25926         if rv.Kind() == reflect.Ptr {
25927                 vp := rv2i(rv).(*map[uint16]int32)
25928                 v, changed := fastpathTV.DecMapUint16Int32V(*vp, true, d)
25929                 if changed {
25930                         *vp = v
25931                 }
25932         } else {
25933                 fastpathTV.DecMapUint16Int32V(rv2i(rv).(map[uint16]int32), false, d)
25934         }
25935 }
25936 func (f fastpathT) DecMapUint16Int32X(vp *map[uint16]int32, d *Decoder) {
25937         v, changed := f.DecMapUint16Int32V(*vp, true, d)
25938         if changed {
25939                 *vp = v
25940         }
25941 }
25942 func (_ fastpathT) DecMapUint16Int32V(v map[uint16]int32, canChange bool,
25943         d *Decoder) (_ map[uint16]int32, changed bool) {
25944         dd, esep := d.d, d.hh.hasElemSeparators()
25945         containerLen := dd.ReadMapStart()
25946         if canChange && v == nil {
25947                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
25948                 v = make(map[uint16]int32, xlen)
25949                 changed = true
25950         }
25951         if containerLen == 0 {
25952                 dd.ReadMapEnd()
25953                 return v, changed
25954         }
25955         d.depthIncr()
25956         var mk uint16
25957         var mv int32
25958         hasLen := containerLen > 0
25959         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25960                 if esep {
25961                         dd.ReadMapElemKey()
25962                 }
25963                 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25964                 if esep {
25965                         dd.ReadMapElemValue()
25966                 }
25967                 if dd.TryDecodeAsNil() {
25968                         if v == nil {
25969                         } else if d.h.DeleteOnNilMapValue {
25970                                 delete(v, mk)
25971                         } else {
25972                                 v[mk] = 0
25973                         }
25974                         continue
25975                 }
25976                 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
25977                 if v != nil {
25978                         v[mk] = mv
25979                 }
25980         }
25981         dd.ReadMapEnd()
25982         d.depthDecr()
25983         return v, changed
25984 }
25985
25986 func (d *Decoder) fastpathDecMapUint16Int64R(f *codecFnInfo, rv reflect.Value) {
25987         if rv.Kind() == reflect.Ptr {
25988                 vp := rv2i(rv).(*map[uint16]int64)
25989                 v, changed := fastpathTV.DecMapUint16Int64V(*vp, true, d)
25990                 if changed {
25991                         *vp = v
25992                 }
25993         } else {
25994                 fastpathTV.DecMapUint16Int64V(rv2i(rv).(map[uint16]int64), false, d)
25995         }
25996 }
25997 func (f fastpathT) DecMapUint16Int64X(vp *map[uint16]int64, d *Decoder) {
25998         v, changed := f.DecMapUint16Int64V(*vp, true, d)
25999         if changed {
26000                 *vp = v
26001         }
26002 }
26003 func (_ fastpathT) DecMapUint16Int64V(v map[uint16]int64, canChange bool,
26004         d *Decoder) (_ map[uint16]int64, changed bool) {
26005         dd, esep := d.d, d.hh.hasElemSeparators()
26006         containerLen := dd.ReadMapStart()
26007         if canChange && v == nil {
26008                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
26009                 v = make(map[uint16]int64, xlen)
26010                 changed = true
26011         }
26012         if containerLen == 0 {
26013                 dd.ReadMapEnd()
26014                 return v, changed
26015         }
26016         d.depthIncr()
26017         var mk uint16
26018         var mv int64
26019         hasLen := containerLen > 0
26020         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26021                 if esep {
26022                         dd.ReadMapElemKey()
26023                 }
26024                 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
26025                 if esep {
26026                         dd.ReadMapElemValue()
26027                 }
26028                 if dd.TryDecodeAsNil() {
26029                         if v == nil {
26030                         } else if d.h.DeleteOnNilMapValue {
26031                                 delete(v, mk)
26032                         } else {
26033                                 v[mk] = 0
26034                         }
26035                         continue
26036                 }
26037                 mv = dd.DecodeInt64()
26038                 if v != nil {
26039                         v[mk] = mv
26040                 }
26041         }
26042         dd.ReadMapEnd()
26043         d.depthDecr()
26044         return v, changed
26045 }
26046
26047 func (d *Decoder) fastpathDecMapUint16Float32R(f *codecFnInfo, rv reflect.Value) {
26048         if rv.Kind() == reflect.Ptr {
26049                 vp := rv2i(rv).(*map[uint16]float32)
26050                 v, changed := fastpathTV.DecMapUint16Float32V(*vp, true, d)
26051                 if changed {
26052                         *vp = v
26053                 }
26054         } else {
26055                 fastpathTV.DecMapUint16Float32V(rv2i(rv).(map[uint16]float32), false, d)
26056         }
26057 }
26058 func (f fastpathT) DecMapUint16Float32X(vp *map[uint16]float32, d *Decoder) {
26059         v, changed := f.DecMapUint16Float32V(*vp, true, d)
26060         if changed {
26061                 *vp = v
26062         }
26063 }
26064 func (_ fastpathT) DecMapUint16Float32V(v map[uint16]float32, canChange bool,
26065         d *Decoder) (_ map[uint16]float32, changed bool) {
26066         dd, esep := d.d, d.hh.hasElemSeparators()
26067         containerLen := dd.ReadMapStart()
26068         if canChange && v == nil {
26069                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
26070                 v = make(map[uint16]float32, xlen)
26071                 changed = true
26072         }
26073         if containerLen == 0 {
26074                 dd.ReadMapEnd()
26075                 return v, changed
26076         }
26077         d.depthIncr()
26078         var mk uint16
26079         var mv float32
26080         hasLen := containerLen > 0
26081         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26082                 if esep {
26083                         dd.ReadMapElemKey()
26084                 }
26085                 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
26086                 if esep {
26087                         dd.ReadMapElemValue()
26088                 }
26089                 if dd.TryDecodeAsNil() {
26090                         if v == nil {
26091                         } else if d.h.DeleteOnNilMapValue {
26092                                 delete(v, mk)
26093                         } else {
26094                                 v[mk] = 0
26095                         }
26096                         continue
26097                 }
26098                 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
26099                 if v != nil {
26100                         v[mk] = mv
26101                 }
26102         }
26103         dd.ReadMapEnd()
26104         d.depthDecr()
26105         return v, changed
26106 }
26107
26108 func (d *Decoder) fastpathDecMapUint16Float64R(f *codecFnInfo, rv reflect.Value) {
26109         if rv.Kind() == reflect.Ptr {
26110                 vp := rv2i(rv).(*map[uint16]float64)
26111                 v, changed := fastpathTV.DecMapUint16Float64V(*vp, true, d)
26112                 if changed {
26113                         *vp = v
26114                 }
26115         } else {
26116                 fastpathTV.DecMapUint16Float64V(rv2i(rv).(map[uint16]float64), false, d)
26117         }
26118 }
26119 func (f fastpathT) DecMapUint16Float64X(vp *map[uint16]float64, d *Decoder) {
26120         v, changed := f.DecMapUint16Float64V(*vp, true, d)
26121         if changed {
26122                 *vp = v
26123         }
26124 }
26125 func (_ fastpathT) DecMapUint16Float64V(v map[uint16]float64, canChange bool,
26126         d *Decoder) (_ map[uint16]float64, changed bool) {
26127         dd, esep := d.d, d.hh.hasElemSeparators()
26128         containerLen := dd.ReadMapStart()
26129         if canChange && v == nil {
26130                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
26131                 v = make(map[uint16]float64, xlen)
26132                 changed = true
26133         }
26134         if containerLen == 0 {
26135                 dd.ReadMapEnd()
26136                 return v, changed
26137         }
26138         d.depthIncr()
26139         var mk uint16
26140         var mv float64
26141         hasLen := containerLen > 0
26142         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26143                 if esep {
26144                         dd.ReadMapElemKey()
26145                 }
26146                 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
26147                 if esep {
26148                         dd.ReadMapElemValue()
26149                 }
26150                 if dd.TryDecodeAsNil() {
26151                         if v == nil {
26152                         } else if d.h.DeleteOnNilMapValue {
26153                                 delete(v, mk)
26154                         } else {
26155                                 v[mk] = 0
26156                         }
26157                         continue
26158                 }
26159                 mv = dd.DecodeFloat64()
26160                 if v != nil {
26161                         v[mk] = mv
26162                 }
26163         }
26164         dd.ReadMapEnd()
26165         d.depthDecr()
26166         return v, changed
26167 }
26168
26169 func (d *Decoder) fastpathDecMapUint16BoolR(f *codecFnInfo, rv reflect.Value) {
26170         if rv.Kind() == reflect.Ptr {
26171                 vp := rv2i(rv).(*map[uint16]bool)
26172                 v, changed := fastpathTV.DecMapUint16BoolV(*vp, true, d)
26173                 if changed {
26174                         *vp = v
26175                 }
26176         } else {
26177                 fastpathTV.DecMapUint16BoolV(rv2i(rv).(map[uint16]bool), false, d)
26178         }
26179 }
26180 func (f fastpathT) DecMapUint16BoolX(vp *map[uint16]bool, d *Decoder) {
26181         v, changed := f.DecMapUint16BoolV(*vp, true, d)
26182         if changed {
26183                 *vp = v
26184         }
26185 }
26186 func (_ fastpathT) DecMapUint16BoolV(v map[uint16]bool, canChange bool,
26187         d *Decoder) (_ map[uint16]bool, changed bool) {
26188         dd, esep := d.d, d.hh.hasElemSeparators()
26189         containerLen := dd.ReadMapStart()
26190         if canChange && v == nil {
26191                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
26192                 v = make(map[uint16]bool, xlen)
26193                 changed = true
26194         }
26195         if containerLen == 0 {
26196                 dd.ReadMapEnd()
26197                 return v, changed
26198         }
26199         d.depthIncr()
26200         var mk uint16
26201         var mv bool
26202         hasLen := containerLen > 0
26203         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26204                 if esep {
26205                         dd.ReadMapElemKey()
26206                 }
26207                 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
26208                 if esep {
26209                         dd.ReadMapElemValue()
26210                 }
26211                 if dd.TryDecodeAsNil() {
26212                         if v == nil {
26213                         } else if d.h.DeleteOnNilMapValue {
26214                                 delete(v, mk)
26215                         } else {
26216                                 v[mk] = false
26217                         }
26218                         continue
26219                 }
26220                 mv = dd.DecodeBool()
26221                 if v != nil {
26222                         v[mk] = mv
26223                 }
26224         }
26225         dd.ReadMapEnd()
26226         d.depthDecr()
26227         return v, changed
26228 }
26229
26230 func (d *Decoder) fastpathDecMapUint32IntfR(f *codecFnInfo, rv reflect.Value) {
26231         if rv.Kind() == reflect.Ptr {
26232                 vp := rv2i(rv).(*map[uint32]interface{})
26233                 v, changed := fastpathTV.DecMapUint32IntfV(*vp, true, d)
26234                 if changed {
26235                         *vp = v
26236                 }
26237         } else {
26238                 fastpathTV.DecMapUint32IntfV(rv2i(rv).(map[uint32]interface{}), false, d)
26239         }
26240 }
26241 func (f fastpathT) DecMapUint32IntfX(vp *map[uint32]interface{}, d *Decoder) {
26242         v, changed := f.DecMapUint32IntfV(*vp, true, d)
26243         if changed {
26244                 *vp = v
26245         }
26246 }
26247 func (_ fastpathT) DecMapUint32IntfV(v map[uint32]interface{}, canChange bool,
26248         d *Decoder) (_ map[uint32]interface{}, changed bool) {
26249         dd, esep := d.d, d.hh.hasElemSeparators()
26250         containerLen := dd.ReadMapStart()
26251         if canChange && v == nil {
26252                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
26253                 v = make(map[uint32]interface{}, xlen)
26254                 changed = true
26255         }
26256         if containerLen == 0 {
26257                 dd.ReadMapEnd()
26258                 return v, changed
26259         }
26260         d.depthIncr()
26261         mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
26262         var mk uint32
26263         var mv interface{}
26264         hasLen := containerLen > 0
26265         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26266                 if esep {
26267                         dd.ReadMapElemKey()
26268                 }
26269                 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26270                 if esep {
26271                         dd.ReadMapElemValue()
26272                 }
26273                 if dd.TryDecodeAsNil() {
26274                         if v == nil {
26275                         } else if d.h.DeleteOnNilMapValue {
26276                                 delete(v, mk)
26277                         } else {
26278                                 v[mk] = nil
26279                         }
26280                         continue
26281                 }
26282                 if mapGet {
26283                         mv = v[mk]
26284                 } else {
26285                         mv = nil
26286                 }
26287                 d.decode(&mv)
26288                 if v != nil {
26289                         v[mk] = mv
26290                 }
26291         }
26292         dd.ReadMapEnd()
26293         d.depthDecr()
26294         return v, changed
26295 }
26296
26297 func (d *Decoder) fastpathDecMapUint32StringR(f *codecFnInfo, rv reflect.Value) {
26298         if rv.Kind() == reflect.Ptr {
26299                 vp := rv2i(rv).(*map[uint32]string)
26300                 v, changed := fastpathTV.DecMapUint32StringV(*vp, true, d)
26301                 if changed {
26302                         *vp = v
26303                 }
26304         } else {
26305                 fastpathTV.DecMapUint32StringV(rv2i(rv).(map[uint32]string), false, d)
26306         }
26307 }
26308 func (f fastpathT) DecMapUint32StringX(vp *map[uint32]string, d *Decoder) {
26309         v, changed := f.DecMapUint32StringV(*vp, true, d)
26310         if changed {
26311                 *vp = v
26312         }
26313 }
26314 func (_ fastpathT) DecMapUint32StringV(v map[uint32]string, canChange bool,
26315         d *Decoder) (_ map[uint32]string, changed bool) {
26316         dd, esep := d.d, d.hh.hasElemSeparators()
26317         containerLen := dd.ReadMapStart()
26318         if canChange && v == nil {
26319                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
26320                 v = make(map[uint32]string, xlen)
26321                 changed = true
26322         }
26323         if containerLen == 0 {
26324                 dd.ReadMapEnd()
26325                 return v, changed
26326         }
26327         d.depthIncr()
26328         var mk uint32
26329         var mv string
26330         hasLen := containerLen > 0
26331         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26332                 if esep {
26333                         dd.ReadMapElemKey()
26334                 }
26335                 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26336                 if esep {
26337                         dd.ReadMapElemValue()
26338                 }
26339                 if dd.TryDecodeAsNil() {
26340                         if v == nil {
26341                         } else if d.h.DeleteOnNilMapValue {
26342                                 delete(v, mk)
26343                         } else {
26344                                 v[mk] = ""
26345                         }
26346                         continue
26347                 }
26348                 mv = dd.DecodeString()
26349                 if v != nil {
26350                         v[mk] = mv
26351                 }
26352         }
26353         dd.ReadMapEnd()
26354         d.depthDecr()
26355         return v, changed
26356 }
26357
26358 func (d *Decoder) fastpathDecMapUint32UintR(f *codecFnInfo, rv reflect.Value) {
26359         if rv.Kind() == reflect.Ptr {
26360                 vp := rv2i(rv).(*map[uint32]uint)
26361                 v, changed := fastpathTV.DecMapUint32UintV(*vp, true, d)
26362                 if changed {
26363                         *vp = v
26364                 }
26365         } else {
26366                 fastpathTV.DecMapUint32UintV(rv2i(rv).(map[uint32]uint), false, d)
26367         }
26368 }
26369 func (f fastpathT) DecMapUint32UintX(vp *map[uint32]uint, d *Decoder) {
26370         v, changed := f.DecMapUint32UintV(*vp, true, d)
26371         if changed {
26372                 *vp = v
26373         }
26374 }
26375 func (_ fastpathT) DecMapUint32UintV(v map[uint32]uint, canChange bool,
26376         d *Decoder) (_ map[uint32]uint, changed bool) {
26377         dd, esep := d.d, d.hh.hasElemSeparators()
26378         containerLen := dd.ReadMapStart()
26379         if canChange && v == nil {
26380                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
26381                 v = make(map[uint32]uint, xlen)
26382                 changed = true
26383         }
26384         if containerLen == 0 {
26385                 dd.ReadMapEnd()
26386                 return v, changed
26387         }
26388         d.depthIncr()
26389         var mk uint32
26390         var mv uint
26391         hasLen := containerLen > 0
26392         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26393                 if esep {
26394                         dd.ReadMapElemKey()
26395                 }
26396                 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26397                 if esep {
26398                         dd.ReadMapElemValue()
26399                 }
26400                 if dd.TryDecodeAsNil() {
26401                         if v == nil {
26402                         } else if d.h.DeleteOnNilMapValue {
26403                                 delete(v, mk)
26404                         } else {
26405                                 v[mk] = 0
26406                         }
26407                         continue
26408                 }
26409                 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
26410                 if v != nil {
26411                         v[mk] = mv
26412                 }
26413         }
26414         dd.ReadMapEnd()
26415         d.depthDecr()
26416         return v, changed
26417 }
26418
26419 func (d *Decoder) fastpathDecMapUint32Uint8R(f *codecFnInfo, rv reflect.Value) {
26420         if rv.Kind() == reflect.Ptr {
26421                 vp := rv2i(rv).(*map[uint32]uint8)
26422                 v, changed := fastpathTV.DecMapUint32Uint8V(*vp, true, d)
26423                 if changed {
26424                         *vp = v
26425                 }
26426         } else {
26427                 fastpathTV.DecMapUint32Uint8V(rv2i(rv).(map[uint32]uint8), false, d)
26428         }
26429 }
26430 func (f fastpathT) DecMapUint32Uint8X(vp *map[uint32]uint8, d *Decoder) {
26431         v, changed := f.DecMapUint32Uint8V(*vp, true, d)
26432         if changed {
26433                 *vp = v
26434         }
26435 }
26436 func (_ fastpathT) DecMapUint32Uint8V(v map[uint32]uint8, canChange bool,
26437         d *Decoder) (_ map[uint32]uint8, changed bool) {
26438         dd, esep := d.d, d.hh.hasElemSeparators()
26439         containerLen := dd.ReadMapStart()
26440         if canChange && v == nil {
26441                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
26442                 v = make(map[uint32]uint8, xlen)
26443                 changed = true
26444         }
26445         if containerLen == 0 {
26446                 dd.ReadMapEnd()
26447                 return v, changed
26448         }
26449         d.depthIncr()
26450         var mk uint32
26451         var mv uint8
26452         hasLen := containerLen > 0
26453         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26454                 if esep {
26455                         dd.ReadMapElemKey()
26456                 }
26457                 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26458                 if esep {
26459                         dd.ReadMapElemValue()
26460                 }
26461                 if dd.TryDecodeAsNil() {
26462                         if v == nil {
26463                         } else if d.h.DeleteOnNilMapValue {
26464                                 delete(v, mk)
26465                         } else {
26466                                 v[mk] = 0
26467                         }
26468                         continue
26469                 }
26470                 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
26471                 if v != nil {
26472                         v[mk] = mv
26473                 }
26474         }
26475         dd.ReadMapEnd()
26476         d.depthDecr()
26477         return v, changed
26478 }
26479
26480 func (d *Decoder) fastpathDecMapUint32Uint16R(f *codecFnInfo, rv reflect.Value) {
26481         if rv.Kind() == reflect.Ptr {
26482                 vp := rv2i(rv).(*map[uint32]uint16)
26483                 v, changed := fastpathTV.DecMapUint32Uint16V(*vp, true, d)
26484                 if changed {
26485                         *vp = v
26486                 }
26487         } else {
26488                 fastpathTV.DecMapUint32Uint16V(rv2i(rv).(map[uint32]uint16), false, d)
26489         }
26490 }
26491 func (f fastpathT) DecMapUint32Uint16X(vp *map[uint32]uint16, d *Decoder) {
26492         v, changed := f.DecMapUint32Uint16V(*vp, true, d)
26493         if changed {
26494                 *vp = v
26495         }
26496 }
26497 func (_ fastpathT) DecMapUint32Uint16V(v map[uint32]uint16, canChange bool,
26498         d *Decoder) (_ map[uint32]uint16, changed bool) {
26499         dd, esep := d.d, d.hh.hasElemSeparators()
26500         containerLen := dd.ReadMapStart()
26501         if canChange && v == nil {
26502                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
26503                 v = make(map[uint32]uint16, xlen)
26504                 changed = true
26505         }
26506         if containerLen == 0 {
26507                 dd.ReadMapEnd()
26508                 return v, changed
26509         }
26510         d.depthIncr()
26511         var mk uint32
26512         var mv uint16
26513         hasLen := containerLen > 0
26514         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26515                 if esep {
26516                         dd.ReadMapElemKey()
26517                 }
26518                 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26519                 if esep {
26520                         dd.ReadMapElemValue()
26521                 }
26522                 if dd.TryDecodeAsNil() {
26523                         if v == nil {
26524                         } else if d.h.DeleteOnNilMapValue {
26525                                 delete(v, mk)
26526                         } else {
26527                                 v[mk] = 0
26528                         }
26529                         continue
26530                 }
26531                 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
26532                 if v != nil {
26533                         v[mk] = mv
26534                 }
26535         }
26536         dd.ReadMapEnd()
26537         d.depthDecr()
26538         return v, changed
26539 }
26540
26541 func (d *Decoder) fastpathDecMapUint32Uint32R(f *codecFnInfo, rv reflect.Value) {
26542         if rv.Kind() == reflect.Ptr {
26543                 vp := rv2i(rv).(*map[uint32]uint32)
26544                 v, changed := fastpathTV.DecMapUint32Uint32V(*vp, true, d)
26545                 if changed {
26546                         *vp = v
26547                 }
26548         } else {
26549                 fastpathTV.DecMapUint32Uint32V(rv2i(rv).(map[uint32]uint32), false, d)
26550         }
26551 }
26552 func (f fastpathT) DecMapUint32Uint32X(vp *map[uint32]uint32, d *Decoder) {
26553         v, changed := f.DecMapUint32Uint32V(*vp, true, d)
26554         if changed {
26555                 *vp = v
26556         }
26557 }
26558 func (_ fastpathT) DecMapUint32Uint32V(v map[uint32]uint32, canChange bool,
26559         d *Decoder) (_ map[uint32]uint32, changed bool) {
26560         dd, esep := d.d, d.hh.hasElemSeparators()
26561         containerLen := dd.ReadMapStart()
26562         if canChange && v == nil {
26563                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
26564                 v = make(map[uint32]uint32, xlen)
26565                 changed = true
26566         }
26567         if containerLen == 0 {
26568                 dd.ReadMapEnd()
26569                 return v, changed
26570         }
26571         d.depthIncr()
26572         var mk uint32
26573         var mv uint32
26574         hasLen := containerLen > 0
26575         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26576                 if esep {
26577                         dd.ReadMapElemKey()
26578                 }
26579                 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26580                 if esep {
26581                         dd.ReadMapElemValue()
26582                 }
26583                 if dd.TryDecodeAsNil() {
26584                         if v == nil {
26585                         } else if d.h.DeleteOnNilMapValue {
26586                                 delete(v, mk)
26587                         } else {
26588                                 v[mk] = 0
26589                         }
26590                         continue
26591                 }
26592                 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26593                 if v != nil {
26594                         v[mk] = mv
26595                 }
26596         }
26597         dd.ReadMapEnd()
26598         d.depthDecr()
26599         return v, changed
26600 }
26601
26602 func (d *Decoder) fastpathDecMapUint32Uint64R(f *codecFnInfo, rv reflect.Value) {
26603         if rv.Kind() == reflect.Ptr {
26604                 vp := rv2i(rv).(*map[uint32]uint64)
26605                 v, changed := fastpathTV.DecMapUint32Uint64V(*vp, true, d)
26606                 if changed {
26607                         *vp = v
26608                 }
26609         } else {
26610                 fastpathTV.DecMapUint32Uint64V(rv2i(rv).(map[uint32]uint64), false, d)
26611         }
26612 }
26613 func (f fastpathT) DecMapUint32Uint64X(vp *map[uint32]uint64, d *Decoder) {
26614         v, changed := f.DecMapUint32Uint64V(*vp, true, d)
26615         if changed {
26616                 *vp = v
26617         }
26618 }
26619 func (_ fastpathT) DecMapUint32Uint64V(v map[uint32]uint64, canChange bool,
26620         d *Decoder) (_ map[uint32]uint64, changed bool) {
26621         dd, esep := d.d, d.hh.hasElemSeparators()
26622         containerLen := dd.ReadMapStart()
26623         if canChange && v == nil {
26624                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
26625                 v = make(map[uint32]uint64, xlen)
26626                 changed = true
26627         }
26628         if containerLen == 0 {
26629                 dd.ReadMapEnd()
26630                 return v, changed
26631         }
26632         d.depthIncr()
26633         var mk uint32
26634         var mv uint64
26635         hasLen := containerLen > 0
26636         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26637                 if esep {
26638                         dd.ReadMapElemKey()
26639                 }
26640                 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26641                 if esep {
26642                         dd.ReadMapElemValue()
26643                 }
26644                 if dd.TryDecodeAsNil() {
26645                         if v == nil {
26646                         } else if d.h.DeleteOnNilMapValue {
26647                                 delete(v, mk)
26648                         } else {
26649                                 v[mk] = 0
26650                         }
26651                         continue
26652                 }
26653                 mv = dd.DecodeUint64()
26654                 if v != nil {
26655                         v[mk] = mv
26656                 }
26657         }
26658         dd.ReadMapEnd()
26659         d.depthDecr()
26660         return v, changed
26661 }
26662
26663 func (d *Decoder) fastpathDecMapUint32UintptrR(f *codecFnInfo, rv reflect.Value) {
26664         if rv.Kind() == reflect.Ptr {
26665                 vp := rv2i(rv).(*map[uint32]uintptr)
26666                 v, changed := fastpathTV.DecMapUint32UintptrV(*vp, true, d)
26667                 if changed {
26668                         *vp = v
26669                 }
26670         } else {
26671                 fastpathTV.DecMapUint32UintptrV(rv2i(rv).(map[uint32]uintptr), false, d)
26672         }
26673 }
26674 func (f fastpathT) DecMapUint32UintptrX(vp *map[uint32]uintptr, d *Decoder) {
26675         v, changed := f.DecMapUint32UintptrV(*vp, true, d)
26676         if changed {
26677                 *vp = v
26678         }
26679 }
26680 func (_ fastpathT) DecMapUint32UintptrV(v map[uint32]uintptr, canChange bool,
26681         d *Decoder) (_ map[uint32]uintptr, changed bool) {
26682         dd, esep := d.d, d.hh.hasElemSeparators()
26683         containerLen := dd.ReadMapStart()
26684         if canChange && v == nil {
26685                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
26686                 v = make(map[uint32]uintptr, xlen)
26687                 changed = true
26688         }
26689         if containerLen == 0 {
26690                 dd.ReadMapEnd()
26691                 return v, changed
26692         }
26693         d.depthIncr()
26694         var mk uint32
26695         var mv uintptr
26696         hasLen := containerLen > 0
26697         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26698                 if esep {
26699                         dd.ReadMapElemKey()
26700                 }
26701                 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26702                 if esep {
26703                         dd.ReadMapElemValue()
26704                 }
26705                 if dd.TryDecodeAsNil() {
26706                         if v == nil {
26707                         } else if d.h.DeleteOnNilMapValue {
26708                                 delete(v, mk)
26709                         } else {
26710                                 v[mk] = 0
26711                         }
26712                         continue
26713                 }
26714                 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
26715                 if v != nil {
26716                         v[mk] = mv
26717                 }
26718         }
26719         dd.ReadMapEnd()
26720         d.depthDecr()
26721         return v, changed
26722 }
26723
26724 func (d *Decoder) fastpathDecMapUint32IntR(f *codecFnInfo, rv reflect.Value) {
26725         if rv.Kind() == reflect.Ptr {
26726                 vp := rv2i(rv).(*map[uint32]int)
26727                 v, changed := fastpathTV.DecMapUint32IntV(*vp, true, d)
26728                 if changed {
26729                         *vp = v
26730                 }
26731         } else {
26732                 fastpathTV.DecMapUint32IntV(rv2i(rv).(map[uint32]int), false, d)
26733         }
26734 }
26735 func (f fastpathT) DecMapUint32IntX(vp *map[uint32]int, d *Decoder) {
26736         v, changed := f.DecMapUint32IntV(*vp, true, d)
26737         if changed {
26738                 *vp = v
26739         }
26740 }
26741 func (_ fastpathT) DecMapUint32IntV(v map[uint32]int, canChange bool,
26742         d *Decoder) (_ map[uint32]int, changed bool) {
26743         dd, esep := d.d, d.hh.hasElemSeparators()
26744         containerLen := dd.ReadMapStart()
26745         if canChange && v == nil {
26746                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
26747                 v = make(map[uint32]int, xlen)
26748                 changed = true
26749         }
26750         if containerLen == 0 {
26751                 dd.ReadMapEnd()
26752                 return v, changed
26753         }
26754         d.depthIncr()
26755         var mk uint32
26756         var mv int
26757         hasLen := containerLen > 0
26758         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26759                 if esep {
26760                         dd.ReadMapElemKey()
26761                 }
26762                 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26763                 if esep {
26764                         dd.ReadMapElemValue()
26765                 }
26766                 if dd.TryDecodeAsNil() {
26767                         if v == nil {
26768                         } else if d.h.DeleteOnNilMapValue {
26769                                 delete(v, mk)
26770                         } else {
26771                                 v[mk] = 0
26772                         }
26773                         continue
26774                 }
26775                 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
26776                 if v != nil {
26777                         v[mk] = mv
26778                 }
26779         }
26780         dd.ReadMapEnd()
26781         d.depthDecr()
26782         return v, changed
26783 }
26784
26785 func (d *Decoder) fastpathDecMapUint32Int8R(f *codecFnInfo, rv reflect.Value) {
26786         if rv.Kind() == reflect.Ptr {
26787                 vp := rv2i(rv).(*map[uint32]int8)
26788                 v, changed := fastpathTV.DecMapUint32Int8V(*vp, true, d)
26789                 if changed {
26790                         *vp = v
26791                 }
26792         } else {
26793                 fastpathTV.DecMapUint32Int8V(rv2i(rv).(map[uint32]int8), false, d)
26794         }
26795 }
26796 func (f fastpathT) DecMapUint32Int8X(vp *map[uint32]int8, d *Decoder) {
26797         v, changed := f.DecMapUint32Int8V(*vp, true, d)
26798         if changed {
26799                 *vp = v
26800         }
26801 }
26802 func (_ fastpathT) DecMapUint32Int8V(v map[uint32]int8, canChange bool,
26803         d *Decoder) (_ map[uint32]int8, changed bool) {
26804         dd, esep := d.d, d.hh.hasElemSeparators()
26805         containerLen := dd.ReadMapStart()
26806         if canChange && v == nil {
26807                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
26808                 v = make(map[uint32]int8, xlen)
26809                 changed = true
26810         }
26811         if containerLen == 0 {
26812                 dd.ReadMapEnd()
26813                 return v, changed
26814         }
26815         d.depthIncr()
26816         var mk uint32
26817         var mv int8
26818         hasLen := containerLen > 0
26819         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26820                 if esep {
26821                         dd.ReadMapElemKey()
26822                 }
26823                 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26824                 if esep {
26825                         dd.ReadMapElemValue()
26826                 }
26827                 if dd.TryDecodeAsNil() {
26828                         if v == nil {
26829                         } else if d.h.DeleteOnNilMapValue {
26830                                 delete(v, mk)
26831                         } else {
26832                                 v[mk] = 0
26833                         }
26834                         continue
26835                 }
26836                 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
26837                 if v != nil {
26838                         v[mk] = mv
26839                 }
26840         }
26841         dd.ReadMapEnd()
26842         d.depthDecr()
26843         return v, changed
26844 }
26845
26846 func (d *Decoder) fastpathDecMapUint32Int16R(f *codecFnInfo, rv reflect.Value) {
26847         if rv.Kind() == reflect.Ptr {
26848                 vp := rv2i(rv).(*map[uint32]int16)
26849                 v, changed := fastpathTV.DecMapUint32Int16V(*vp, true, d)
26850                 if changed {
26851                         *vp = v
26852                 }
26853         } else {
26854                 fastpathTV.DecMapUint32Int16V(rv2i(rv).(map[uint32]int16), false, d)
26855         }
26856 }
26857 func (f fastpathT) DecMapUint32Int16X(vp *map[uint32]int16, d *Decoder) {
26858         v, changed := f.DecMapUint32Int16V(*vp, true, d)
26859         if changed {
26860                 *vp = v
26861         }
26862 }
26863 func (_ fastpathT) DecMapUint32Int16V(v map[uint32]int16, canChange bool,
26864         d *Decoder) (_ map[uint32]int16, changed bool) {
26865         dd, esep := d.d, d.hh.hasElemSeparators()
26866         containerLen := dd.ReadMapStart()
26867         if canChange && v == nil {
26868                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
26869                 v = make(map[uint32]int16, xlen)
26870                 changed = true
26871         }
26872         if containerLen == 0 {
26873                 dd.ReadMapEnd()
26874                 return v, changed
26875         }
26876         d.depthIncr()
26877         var mk uint32
26878         var mv int16
26879         hasLen := containerLen > 0
26880         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26881                 if esep {
26882                         dd.ReadMapElemKey()
26883                 }
26884                 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26885                 if esep {
26886                         dd.ReadMapElemValue()
26887                 }
26888                 if dd.TryDecodeAsNil() {
26889                         if v == nil {
26890                         } else if d.h.DeleteOnNilMapValue {
26891                                 delete(v, mk)
26892                         } else {
26893                                 v[mk] = 0
26894                         }
26895                         continue
26896                 }
26897                 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
26898                 if v != nil {
26899                         v[mk] = mv
26900                 }
26901         }
26902         dd.ReadMapEnd()
26903         d.depthDecr()
26904         return v, changed
26905 }
26906
26907 func (d *Decoder) fastpathDecMapUint32Int32R(f *codecFnInfo, rv reflect.Value) {
26908         if rv.Kind() == reflect.Ptr {
26909                 vp := rv2i(rv).(*map[uint32]int32)
26910                 v, changed := fastpathTV.DecMapUint32Int32V(*vp, true, d)
26911                 if changed {
26912                         *vp = v
26913                 }
26914         } else {
26915                 fastpathTV.DecMapUint32Int32V(rv2i(rv).(map[uint32]int32), false, d)
26916         }
26917 }
26918 func (f fastpathT) DecMapUint32Int32X(vp *map[uint32]int32, d *Decoder) {
26919         v, changed := f.DecMapUint32Int32V(*vp, true, d)
26920         if changed {
26921                 *vp = v
26922         }
26923 }
26924 func (_ fastpathT) DecMapUint32Int32V(v map[uint32]int32, canChange bool,
26925         d *Decoder) (_ map[uint32]int32, changed bool) {
26926         dd, esep := d.d, d.hh.hasElemSeparators()
26927         containerLen := dd.ReadMapStart()
26928         if canChange && v == nil {
26929                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
26930                 v = make(map[uint32]int32, xlen)
26931                 changed = true
26932         }
26933         if containerLen == 0 {
26934                 dd.ReadMapEnd()
26935                 return v, changed
26936         }
26937         d.depthIncr()
26938         var mk uint32
26939         var mv int32
26940         hasLen := containerLen > 0
26941         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26942                 if esep {
26943                         dd.ReadMapElemKey()
26944                 }
26945                 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26946                 if esep {
26947                         dd.ReadMapElemValue()
26948                 }
26949                 if dd.TryDecodeAsNil() {
26950                         if v == nil {
26951                         } else if d.h.DeleteOnNilMapValue {
26952                                 delete(v, mk)
26953                         } else {
26954                                 v[mk] = 0
26955                         }
26956                         continue
26957                 }
26958                 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
26959                 if v != nil {
26960                         v[mk] = mv
26961                 }
26962         }
26963         dd.ReadMapEnd()
26964         d.depthDecr()
26965         return v, changed
26966 }
26967
26968 func (d *Decoder) fastpathDecMapUint32Int64R(f *codecFnInfo, rv reflect.Value) {
26969         if rv.Kind() == reflect.Ptr {
26970                 vp := rv2i(rv).(*map[uint32]int64)
26971                 v, changed := fastpathTV.DecMapUint32Int64V(*vp, true, d)
26972                 if changed {
26973                         *vp = v
26974                 }
26975         } else {
26976                 fastpathTV.DecMapUint32Int64V(rv2i(rv).(map[uint32]int64), false, d)
26977         }
26978 }
26979 func (f fastpathT) DecMapUint32Int64X(vp *map[uint32]int64, d *Decoder) {
26980         v, changed := f.DecMapUint32Int64V(*vp, true, d)
26981         if changed {
26982                 *vp = v
26983         }
26984 }
26985 func (_ fastpathT) DecMapUint32Int64V(v map[uint32]int64, canChange bool,
26986         d *Decoder) (_ map[uint32]int64, changed bool) {
26987         dd, esep := d.d, d.hh.hasElemSeparators()
26988         containerLen := dd.ReadMapStart()
26989         if canChange && v == nil {
26990                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
26991                 v = make(map[uint32]int64, xlen)
26992                 changed = true
26993         }
26994         if containerLen == 0 {
26995                 dd.ReadMapEnd()
26996                 return v, changed
26997         }
26998         d.depthIncr()
26999         var mk uint32
27000         var mv int64
27001         hasLen := containerLen > 0
27002         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27003                 if esep {
27004                         dd.ReadMapElemKey()
27005                 }
27006                 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
27007                 if esep {
27008                         dd.ReadMapElemValue()
27009                 }
27010                 if dd.TryDecodeAsNil() {
27011                         if v == nil {
27012                         } else if d.h.DeleteOnNilMapValue {
27013                                 delete(v, mk)
27014                         } else {
27015                                 v[mk] = 0
27016                         }
27017                         continue
27018                 }
27019                 mv = dd.DecodeInt64()
27020                 if v != nil {
27021                         v[mk] = mv
27022                 }
27023         }
27024         dd.ReadMapEnd()
27025         d.depthDecr()
27026         return v, changed
27027 }
27028
27029 func (d *Decoder) fastpathDecMapUint32Float32R(f *codecFnInfo, rv reflect.Value) {
27030         if rv.Kind() == reflect.Ptr {
27031                 vp := rv2i(rv).(*map[uint32]float32)
27032                 v, changed := fastpathTV.DecMapUint32Float32V(*vp, true, d)
27033                 if changed {
27034                         *vp = v
27035                 }
27036         } else {
27037                 fastpathTV.DecMapUint32Float32V(rv2i(rv).(map[uint32]float32), false, d)
27038         }
27039 }
27040 func (f fastpathT) DecMapUint32Float32X(vp *map[uint32]float32, d *Decoder) {
27041         v, changed := f.DecMapUint32Float32V(*vp, true, d)
27042         if changed {
27043                 *vp = v
27044         }
27045 }
27046 func (_ fastpathT) DecMapUint32Float32V(v map[uint32]float32, canChange bool,
27047         d *Decoder) (_ map[uint32]float32, changed bool) {
27048         dd, esep := d.d, d.hh.hasElemSeparators()
27049         containerLen := dd.ReadMapStart()
27050         if canChange && v == nil {
27051                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
27052                 v = make(map[uint32]float32, xlen)
27053                 changed = true
27054         }
27055         if containerLen == 0 {
27056                 dd.ReadMapEnd()
27057                 return v, changed
27058         }
27059         d.depthIncr()
27060         var mk uint32
27061         var mv float32
27062         hasLen := containerLen > 0
27063         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27064                 if esep {
27065                         dd.ReadMapElemKey()
27066                 }
27067                 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
27068                 if esep {
27069                         dd.ReadMapElemValue()
27070                 }
27071                 if dd.TryDecodeAsNil() {
27072                         if v == nil {
27073                         } else if d.h.DeleteOnNilMapValue {
27074                                 delete(v, mk)
27075                         } else {
27076                                 v[mk] = 0
27077                         }
27078                         continue
27079                 }
27080                 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
27081                 if v != nil {
27082                         v[mk] = mv
27083                 }
27084         }
27085         dd.ReadMapEnd()
27086         d.depthDecr()
27087         return v, changed
27088 }
27089
27090 func (d *Decoder) fastpathDecMapUint32Float64R(f *codecFnInfo, rv reflect.Value) {
27091         if rv.Kind() == reflect.Ptr {
27092                 vp := rv2i(rv).(*map[uint32]float64)
27093                 v, changed := fastpathTV.DecMapUint32Float64V(*vp, true, d)
27094                 if changed {
27095                         *vp = v
27096                 }
27097         } else {
27098                 fastpathTV.DecMapUint32Float64V(rv2i(rv).(map[uint32]float64), false, d)
27099         }
27100 }
27101 func (f fastpathT) DecMapUint32Float64X(vp *map[uint32]float64, d *Decoder) {
27102         v, changed := f.DecMapUint32Float64V(*vp, true, d)
27103         if changed {
27104                 *vp = v
27105         }
27106 }
27107 func (_ fastpathT) DecMapUint32Float64V(v map[uint32]float64, canChange bool,
27108         d *Decoder) (_ map[uint32]float64, changed bool) {
27109         dd, esep := d.d, d.hh.hasElemSeparators()
27110         containerLen := dd.ReadMapStart()
27111         if canChange && v == nil {
27112                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
27113                 v = make(map[uint32]float64, xlen)
27114                 changed = true
27115         }
27116         if containerLen == 0 {
27117                 dd.ReadMapEnd()
27118                 return v, changed
27119         }
27120         d.depthIncr()
27121         var mk uint32
27122         var mv float64
27123         hasLen := containerLen > 0
27124         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27125                 if esep {
27126                         dd.ReadMapElemKey()
27127                 }
27128                 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
27129                 if esep {
27130                         dd.ReadMapElemValue()
27131                 }
27132                 if dd.TryDecodeAsNil() {
27133                         if v == nil {
27134                         } else if d.h.DeleteOnNilMapValue {
27135                                 delete(v, mk)
27136                         } else {
27137                                 v[mk] = 0
27138                         }
27139                         continue
27140                 }
27141                 mv = dd.DecodeFloat64()
27142                 if v != nil {
27143                         v[mk] = mv
27144                 }
27145         }
27146         dd.ReadMapEnd()
27147         d.depthDecr()
27148         return v, changed
27149 }
27150
27151 func (d *Decoder) fastpathDecMapUint32BoolR(f *codecFnInfo, rv reflect.Value) {
27152         if rv.Kind() == reflect.Ptr {
27153                 vp := rv2i(rv).(*map[uint32]bool)
27154                 v, changed := fastpathTV.DecMapUint32BoolV(*vp, true, d)
27155                 if changed {
27156                         *vp = v
27157                 }
27158         } else {
27159                 fastpathTV.DecMapUint32BoolV(rv2i(rv).(map[uint32]bool), false, d)
27160         }
27161 }
27162 func (f fastpathT) DecMapUint32BoolX(vp *map[uint32]bool, d *Decoder) {
27163         v, changed := f.DecMapUint32BoolV(*vp, true, d)
27164         if changed {
27165                 *vp = v
27166         }
27167 }
27168 func (_ fastpathT) DecMapUint32BoolV(v map[uint32]bool, canChange bool,
27169         d *Decoder) (_ map[uint32]bool, changed bool) {
27170         dd, esep := d.d, d.hh.hasElemSeparators()
27171         containerLen := dd.ReadMapStart()
27172         if canChange && v == nil {
27173                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
27174                 v = make(map[uint32]bool, xlen)
27175                 changed = true
27176         }
27177         if containerLen == 0 {
27178                 dd.ReadMapEnd()
27179                 return v, changed
27180         }
27181         d.depthIncr()
27182         var mk uint32
27183         var mv bool
27184         hasLen := containerLen > 0
27185         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27186                 if esep {
27187                         dd.ReadMapElemKey()
27188                 }
27189                 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
27190                 if esep {
27191                         dd.ReadMapElemValue()
27192                 }
27193                 if dd.TryDecodeAsNil() {
27194                         if v == nil {
27195                         } else if d.h.DeleteOnNilMapValue {
27196                                 delete(v, mk)
27197                         } else {
27198                                 v[mk] = false
27199                         }
27200                         continue
27201                 }
27202                 mv = dd.DecodeBool()
27203                 if v != nil {
27204                         v[mk] = mv
27205                 }
27206         }
27207         dd.ReadMapEnd()
27208         d.depthDecr()
27209         return v, changed
27210 }
27211
27212 func (d *Decoder) fastpathDecMapUint64IntfR(f *codecFnInfo, rv reflect.Value) {
27213         if rv.Kind() == reflect.Ptr {
27214                 vp := rv2i(rv).(*map[uint64]interface{})
27215                 v, changed := fastpathTV.DecMapUint64IntfV(*vp, true, d)
27216                 if changed {
27217                         *vp = v
27218                 }
27219         } else {
27220                 fastpathTV.DecMapUint64IntfV(rv2i(rv).(map[uint64]interface{}), false, d)
27221         }
27222 }
27223 func (f fastpathT) DecMapUint64IntfX(vp *map[uint64]interface{}, d *Decoder) {
27224         v, changed := f.DecMapUint64IntfV(*vp, true, d)
27225         if changed {
27226                 *vp = v
27227         }
27228 }
27229 func (_ fastpathT) DecMapUint64IntfV(v map[uint64]interface{}, canChange bool,
27230         d *Decoder) (_ map[uint64]interface{}, changed bool) {
27231         dd, esep := d.d, d.hh.hasElemSeparators()
27232         containerLen := dd.ReadMapStart()
27233         if canChange && v == nil {
27234                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
27235                 v = make(map[uint64]interface{}, xlen)
27236                 changed = true
27237         }
27238         if containerLen == 0 {
27239                 dd.ReadMapEnd()
27240                 return v, changed
27241         }
27242         d.depthIncr()
27243         mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
27244         var mk uint64
27245         var mv interface{}
27246         hasLen := containerLen > 0
27247         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27248                 if esep {
27249                         dd.ReadMapElemKey()
27250                 }
27251                 mk = dd.DecodeUint64()
27252                 if esep {
27253                         dd.ReadMapElemValue()
27254                 }
27255                 if dd.TryDecodeAsNil() {
27256                         if v == nil {
27257                         } else if d.h.DeleteOnNilMapValue {
27258                                 delete(v, mk)
27259                         } else {
27260                                 v[mk] = nil
27261                         }
27262                         continue
27263                 }
27264                 if mapGet {
27265                         mv = v[mk]
27266                 } else {
27267                         mv = nil
27268                 }
27269                 d.decode(&mv)
27270                 if v != nil {
27271                         v[mk] = mv
27272                 }
27273         }
27274         dd.ReadMapEnd()
27275         d.depthDecr()
27276         return v, changed
27277 }
27278
27279 func (d *Decoder) fastpathDecMapUint64StringR(f *codecFnInfo, rv reflect.Value) {
27280         if rv.Kind() == reflect.Ptr {
27281                 vp := rv2i(rv).(*map[uint64]string)
27282                 v, changed := fastpathTV.DecMapUint64StringV(*vp, true, d)
27283                 if changed {
27284                         *vp = v
27285                 }
27286         } else {
27287                 fastpathTV.DecMapUint64StringV(rv2i(rv).(map[uint64]string), false, d)
27288         }
27289 }
27290 func (f fastpathT) DecMapUint64StringX(vp *map[uint64]string, d *Decoder) {
27291         v, changed := f.DecMapUint64StringV(*vp, true, d)
27292         if changed {
27293                 *vp = v
27294         }
27295 }
27296 func (_ fastpathT) DecMapUint64StringV(v map[uint64]string, canChange bool,
27297         d *Decoder) (_ map[uint64]string, changed bool) {
27298         dd, esep := d.d, d.hh.hasElemSeparators()
27299         containerLen := dd.ReadMapStart()
27300         if canChange && v == nil {
27301                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
27302                 v = make(map[uint64]string, xlen)
27303                 changed = true
27304         }
27305         if containerLen == 0 {
27306                 dd.ReadMapEnd()
27307                 return v, changed
27308         }
27309         d.depthIncr()
27310         var mk uint64
27311         var mv string
27312         hasLen := containerLen > 0
27313         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27314                 if esep {
27315                         dd.ReadMapElemKey()
27316                 }
27317                 mk = dd.DecodeUint64()
27318                 if esep {
27319                         dd.ReadMapElemValue()
27320                 }
27321                 if dd.TryDecodeAsNil() {
27322                         if v == nil {
27323                         } else if d.h.DeleteOnNilMapValue {
27324                                 delete(v, mk)
27325                         } else {
27326                                 v[mk] = ""
27327                         }
27328                         continue
27329                 }
27330                 mv = dd.DecodeString()
27331                 if v != nil {
27332                         v[mk] = mv
27333                 }
27334         }
27335         dd.ReadMapEnd()
27336         d.depthDecr()
27337         return v, changed
27338 }
27339
27340 func (d *Decoder) fastpathDecMapUint64UintR(f *codecFnInfo, rv reflect.Value) {
27341         if rv.Kind() == reflect.Ptr {
27342                 vp := rv2i(rv).(*map[uint64]uint)
27343                 v, changed := fastpathTV.DecMapUint64UintV(*vp, true, d)
27344                 if changed {
27345                         *vp = v
27346                 }
27347         } else {
27348                 fastpathTV.DecMapUint64UintV(rv2i(rv).(map[uint64]uint), false, d)
27349         }
27350 }
27351 func (f fastpathT) DecMapUint64UintX(vp *map[uint64]uint, d *Decoder) {
27352         v, changed := f.DecMapUint64UintV(*vp, true, d)
27353         if changed {
27354                 *vp = v
27355         }
27356 }
27357 func (_ fastpathT) DecMapUint64UintV(v map[uint64]uint, canChange bool,
27358         d *Decoder) (_ map[uint64]uint, changed bool) {
27359         dd, esep := d.d, d.hh.hasElemSeparators()
27360         containerLen := dd.ReadMapStart()
27361         if canChange && v == nil {
27362                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
27363                 v = make(map[uint64]uint, xlen)
27364                 changed = true
27365         }
27366         if containerLen == 0 {
27367                 dd.ReadMapEnd()
27368                 return v, changed
27369         }
27370         d.depthIncr()
27371         var mk uint64
27372         var mv uint
27373         hasLen := containerLen > 0
27374         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27375                 if esep {
27376                         dd.ReadMapElemKey()
27377                 }
27378                 mk = dd.DecodeUint64()
27379                 if esep {
27380                         dd.ReadMapElemValue()
27381                 }
27382                 if dd.TryDecodeAsNil() {
27383                         if v == nil {
27384                         } else if d.h.DeleteOnNilMapValue {
27385                                 delete(v, mk)
27386                         } else {
27387                                 v[mk] = 0
27388                         }
27389                         continue
27390                 }
27391                 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
27392                 if v != nil {
27393                         v[mk] = mv
27394                 }
27395         }
27396         dd.ReadMapEnd()
27397         d.depthDecr()
27398         return v, changed
27399 }
27400
27401 func (d *Decoder) fastpathDecMapUint64Uint8R(f *codecFnInfo, rv reflect.Value) {
27402         if rv.Kind() == reflect.Ptr {
27403                 vp := rv2i(rv).(*map[uint64]uint8)
27404                 v, changed := fastpathTV.DecMapUint64Uint8V(*vp, true, d)
27405                 if changed {
27406                         *vp = v
27407                 }
27408         } else {
27409                 fastpathTV.DecMapUint64Uint8V(rv2i(rv).(map[uint64]uint8), false, d)
27410         }
27411 }
27412 func (f fastpathT) DecMapUint64Uint8X(vp *map[uint64]uint8, d *Decoder) {
27413         v, changed := f.DecMapUint64Uint8V(*vp, true, d)
27414         if changed {
27415                 *vp = v
27416         }
27417 }
27418 func (_ fastpathT) DecMapUint64Uint8V(v map[uint64]uint8, canChange bool,
27419         d *Decoder) (_ map[uint64]uint8, changed bool) {
27420         dd, esep := d.d, d.hh.hasElemSeparators()
27421         containerLen := dd.ReadMapStart()
27422         if canChange && v == nil {
27423                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
27424                 v = make(map[uint64]uint8, xlen)
27425                 changed = true
27426         }
27427         if containerLen == 0 {
27428                 dd.ReadMapEnd()
27429                 return v, changed
27430         }
27431         d.depthIncr()
27432         var mk uint64
27433         var mv uint8
27434         hasLen := containerLen > 0
27435         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27436                 if esep {
27437                         dd.ReadMapElemKey()
27438                 }
27439                 mk = dd.DecodeUint64()
27440                 if esep {
27441                         dd.ReadMapElemValue()
27442                 }
27443                 if dd.TryDecodeAsNil() {
27444                         if v == nil {
27445                         } else if d.h.DeleteOnNilMapValue {
27446                                 delete(v, mk)
27447                         } else {
27448                                 v[mk] = 0
27449                         }
27450                         continue
27451                 }
27452                 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
27453                 if v != nil {
27454                         v[mk] = mv
27455                 }
27456         }
27457         dd.ReadMapEnd()
27458         d.depthDecr()
27459         return v, changed
27460 }
27461
27462 func (d *Decoder) fastpathDecMapUint64Uint16R(f *codecFnInfo, rv reflect.Value) {
27463         if rv.Kind() == reflect.Ptr {
27464                 vp := rv2i(rv).(*map[uint64]uint16)
27465                 v, changed := fastpathTV.DecMapUint64Uint16V(*vp, true, d)
27466                 if changed {
27467                         *vp = v
27468                 }
27469         } else {
27470                 fastpathTV.DecMapUint64Uint16V(rv2i(rv).(map[uint64]uint16), false, d)
27471         }
27472 }
27473 func (f fastpathT) DecMapUint64Uint16X(vp *map[uint64]uint16, d *Decoder) {
27474         v, changed := f.DecMapUint64Uint16V(*vp, true, d)
27475         if changed {
27476                 *vp = v
27477         }
27478 }
27479 func (_ fastpathT) DecMapUint64Uint16V(v map[uint64]uint16, canChange bool,
27480         d *Decoder) (_ map[uint64]uint16, changed bool) {
27481         dd, esep := d.d, d.hh.hasElemSeparators()
27482         containerLen := dd.ReadMapStart()
27483         if canChange && v == nil {
27484                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
27485                 v = make(map[uint64]uint16, xlen)
27486                 changed = true
27487         }
27488         if containerLen == 0 {
27489                 dd.ReadMapEnd()
27490                 return v, changed
27491         }
27492         d.depthIncr()
27493         var mk uint64
27494         var mv uint16
27495         hasLen := containerLen > 0
27496         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27497                 if esep {
27498                         dd.ReadMapElemKey()
27499                 }
27500                 mk = dd.DecodeUint64()
27501                 if esep {
27502                         dd.ReadMapElemValue()
27503                 }
27504                 if dd.TryDecodeAsNil() {
27505                         if v == nil {
27506                         } else if d.h.DeleteOnNilMapValue {
27507                                 delete(v, mk)
27508                         } else {
27509                                 v[mk] = 0
27510                         }
27511                         continue
27512                 }
27513                 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
27514                 if v != nil {
27515                         v[mk] = mv
27516                 }
27517         }
27518         dd.ReadMapEnd()
27519         d.depthDecr()
27520         return v, changed
27521 }
27522
27523 func (d *Decoder) fastpathDecMapUint64Uint32R(f *codecFnInfo, rv reflect.Value) {
27524         if rv.Kind() == reflect.Ptr {
27525                 vp := rv2i(rv).(*map[uint64]uint32)
27526                 v, changed := fastpathTV.DecMapUint64Uint32V(*vp, true, d)
27527                 if changed {
27528                         *vp = v
27529                 }
27530         } else {
27531                 fastpathTV.DecMapUint64Uint32V(rv2i(rv).(map[uint64]uint32), false, d)
27532         }
27533 }
27534 func (f fastpathT) DecMapUint64Uint32X(vp *map[uint64]uint32, d *Decoder) {
27535         v, changed := f.DecMapUint64Uint32V(*vp, true, d)
27536         if changed {
27537                 *vp = v
27538         }
27539 }
27540 func (_ fastpathT) DecMapUint64Uint32V(v map[uint64]uint32, canChange bool,
27541         d *Decoder) (_ map[uint64]uint32, changed bool) {
27542         dd, esep := d.d, d.hh.hasElemSeparators()
27543         containerLen := dd.ReadMapStart()
27544         if canChange && v == nil {
27545                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
27546                 v = make(map[uint64]uint32, xlen)
27547                 changed = true
27548         }
27549         if containerLen == 0 {
27550                 dd.ReadMapEnd()
27551                 return v, changed
27552         }
27553         d.depthIncr()
27554         var mk uint64
27555         var mv uint32
27556         hasLen := containerLen > 0
27557         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27558                 if esep {
27559                         dd.ReadMapElemKey()
27560                 }
27561                 mk = dd.DecodeUint64()
27562                 if esep {
27563                         dd.ReadMapElemValue()
27564                 }
27565                 if dd.TryDecodeAsNil() {
27566                         if v == nil {
27567                         } else if d.h.DeleteOnNilMapValue {
27568                                 delete(v, mk)
27569                         } else {
27570                                 v[mk] = 0
27571                         }
27572                         continue
27573                 }
27574                 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
27575                 if v != nil {
27576                         v[mk] = mv
27577                 }
27578         }
27579         dd.ReadMapEnd()
27580         d.depthDecr()
27581         return v, changed
27582 }
27583
27584 func (d *Decoder) fastpathDecMapUint64Uint64R(f *codecFnInfo, rv reflect.Value) {
27585         if rv.Kind() == reflect.Ptr {
27586                 vp := rv2i(rv).(*map[uint64]uint64)
27587                 v, changed := fastpathTV.DecMapUint64Uint64V(*vp, true, d)
27588                 if changed {
27589                         *vp = v
27590                 }
27591         } else {
27592                 fastpathTV.DecMapUint64Uint64V(rv2i(rv).(map[uint64]uint64), false, d)
27593         }
27594 }
27595 func (f fastpathT) DecMapUint64Uint64X(vp *map[uint64]uint64, d *Decoder) {
27596         v, changed := f.DecMapUint64Uint64V(*vp, true, d)
27597         if changed {
27598                 *vp = v
27599         }
27600 }
27601 func (_ fastpathT) DecMapUint64Uint64V(v map[uint64]uint64, canChange bool,
27602         d *Decoder) (_ map[uint64]uint64, changed bool) {
27603         dd, esep := d.d, d.hh.hasElemSeparators()
27604         containerLen := dd.ReadMapStart()
27605         if canChange && v == nil {
27606                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
27607                 v = make(map[uint64]uint64, xlen)
27608                 changed = true
27609         }
27610         if containerLen == 0 {
27611                 dd.ReadMapEnd()
27612                 return v, changed
27613         }
27614         d.depthIncr()
27615         var mk uint64
27616         var mv uint64
27617         hasLen := containerLen > 0
27618         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27619                 if esep {
27620                         dd.ReadMapElemKey()
27621                 }
27622                 mk = dd.DecodeUint64()
27623                 if esep {
27624                         dd.ReadMapElemValue()
27625                 }
27626                 if dd.TryDecodeAsNil() {
27627                         if v == nil {
27628                         } else if d.h.DeleteOnNilMapValue {
27629                                 delete(v, mk)
27630                         } else {
27631                                 v[mk] = 0
27632                         }
27633                         continue
27634                 }
27635                 mv = dd.DecodeUint64()
27636                 if v != nil {
27637                         v[mk] = mv
27638                 }
27639         }
27640         dd.ReadMapEnd()
27641         d.depthDecr()
27642         return v, changed
27643 }
27644
27645 func (d *Decoder) fastpathDecMapUint64UintptrR(f *codecFnInfo, rv reflect.Value) {
27646         if rv.Kind() == reflect.Ptr {
27647                 vp := rv2i(rv).(*map[uint64]uintptr)
27648                 v, changed := fastpathTV.DecMapUint64UintptrV(*vp, true, d)
27649                 if changed {
27650                         *vp = v
27651                 }
27652         } else {
27653                 fastpathTV.DecMapUint64UintptrV(rv2i(rv).(map[uint64]uintptr), false, d)
27654         }
27655 }
27656 func (f fastpathT) DecMapUint64UintptrX(vp *map[uint64]uintptr, d *Decoder) {
27657         v, changed := f.DecMapUint64UintptrV(*vp, true, d)
27658         if changed {
27659                 *vp = v
27660         }
27661 }
27662 func (_ fastpathT) DecMapUint64UintptrV(v map[uint64]uintptr, canChange bool,
27663         d *Decoder) (_ map[uint64]uintptr, changed bool) {
27664         dd, esep := d.d, d.hh.hasElemSeparators()
27665         containerLen := dd.ReadMapStart()
27666         if canChange && v == nil {
27667                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
27668                 v = make(map[uint64]uintptr, xlen)
27669                 changed = true
27670         }
27671         if containerLen == 0 {
27672                 dd.ReadMapEnd()
27673                 return v, changed
27674         }
27675         d.depthIncr()
27676         var mk uint64
27677         var mv uintptr
27678         hasLen := containerLen > 0
27679         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27680                 if esep {
27681                         dd.ReadMapElemKey()
27682                 }
27683                 mk = dd.DecodeUint64()
27684                 if esep {
27685                         dd.ReadMapElemValue()
27686                 }
27687                 if dd.TryDecodeAsNil() {
27688                         if v == nil {
27689                         } else if d.h.DeleteOnNilMapValue {
27690                                 delete(v, mk)
27691                         } else {
27692                                 v[mk] = 0
27693                         }
27694                         continue
27695                 }
27696                 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
27697                 if v != nil {
27698                         v[mk] = mv
27699                 }
27700         }
27701         dd.ReadMapEnd()
27702         d.depthDecr()
27703         return v, changed
27704 }
27705
27706 func (d *Decoder) fastpathDecMapUint64IntR(f *codecFnInfo, rv reflect.Value) {
27707         if rv.Kind() == reflect.Ptr {
27708                 vp := rv2i(rv).(*map[uint64]int)
27709                 v, changed := fastpathTV.DecMapUint64IntV(*vp, true, d)
27710                 if changed {
27711                         *vp = v
27712                 }
27713         } else {
27714                 fastpathTV.DecMapUint64IntV(rv2i(rv).(map[uint64]int), false, d)
27715         }
27716 }
27717 func (f fastpathT) DecMapUint64IntX(vp *map[uint64]int, d *Decoder) {
27718         v, changed := f.DecMapUint64IntV(*vp, true, d)
27719         if changed {
27720                 *vp = v
27721         }
27722 }
27723 func (_ fastpathT) DecMapUint64IntV(v map[uint64]int, canChange bool,
27724         d *Decoder) (_ map[uint64]int, changed bool) {
27725         dd, esep := d.d, d.hh.hasElemSeparators()
27726         containerLen := dd.ReadMapStart()
27727         if canChange && v == nil {
27728                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
27729                 v = make(map[uint64]int, xlen)
27730                 changed = true
27731         }
27732         if containerLen == 0 {
27733                 dd.ReadMapEnd()
27734                 return v, changed
27735         }
27736         d.depthIncr()
27737         var mk uint64
27738         var mv int
27739         hasLen := containerLen > 0
27740         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27741                 if esep {
27742                         dd.ReadMapElemKey()
27743                 }
27744                 mk = dd.DecodeUint64()
27745                 if esep {
27746                         dd.ReadMapElemValue()
27747                 }
27748                 if dd.TryDecodeAsNil() {
27749                         if v == nil {
27750                         } else if d.h.DeleteOnNilMapValue {
27751                                 delete(v, mk)
27752                         } else {
27753                                 v[mk] = 0
27754                         }
27755                         continue
27756                 }
27757                 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
27758                 if v != nil {
27759                         v[mk] = mv
27760                 }
27761         }
27762         dd.ReadMapEnd()
27763         d.depthDecr()
27764         return v, changed
27765 }
27766
27767 func (d *Decoder) fastpathDecMapUint64Int8R(f *codecFnInfo, rv reflect.Value) {
27768         if rv.Kind() == reflect.Ptr {
27769                 vp := rv2i(rv).(*map[uint64]int8)
27770                 v, changed := fastpathTV.DecMapUint64Int8V(*vp, true, d)
27771                 if changed {
27772                         *vp = v
27773                 }
27774         } else {
27775                 fastpathTV.DecMapUint64Int8V(rv2i(rv).(map[uint64]int8), false, d)
27776         }
27777 }
27778 func (f fastpathT) DecMapUint64Int8X(vp *map[uint64]int8, d *Decoder) {
27779         v, changed := f.DecMapUint64Int8V(*vp, true, d)
27780         if changed {
27781                 *vp = v
27782         }
27783 }
27784 func (_ fastpathT) DecMapUint64Int8V(v map[uint64]int8, canChange bool,
27785         d *Decoder) (_ map[uint64]int8, changed bool) {
27786         dd, esep := d.d, d.hh.hasElemSeparators()
27787         containerLen := dd.ReadMapStart()
27788         if canChange && v == nil {
27789                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
27790                 v = make(map[uint64]int8, xlen)
27791                 changed = true
27792         }
27793         if containerLen == 0 {
27794                 dd.ReadMapEnd()
27795                 return v, changed
27796         }
27797         d.depthIncr()
27798         var mk uint64
27799         var mv int8
27800         hasLen := containerLen > 0
27801         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27802                 if esep {
27803                         dd.ReadMapElemKey()
27804                 }
27805                 mk = dd.DecodeUint64()
27806                 if esep {
27807                         dd.ReadMapElemValue()
27808                 }
27809                 if dd.TryDecodeAsNil() {
27810                         if v == nil {
27811                         } else if d.h.DeleteOnNilMapValue {
27812                                 delete(v, mk)
27813                         } else {
27814                                 v[mk] = 0
27815                         }
27816                         continue
27817                 }
27818                 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
27819                 if v != nil {
27820                         v[mk] = mv
27821                 }
27822         }
27823         dd.ReadMapEnd()
27824         d.depthDecr()
27825         return v, changed
27826 }
27827
27828 func (d *Decoder) fastpathDecMapUint64Int16R(f *codecFnInfo, rv reflect.Value) {
27829         if rv.Kind() == reflect.Ptr {
27830                 vp := rv2i(rv).(*map[uint64]int16)
27831                 v, changed := fastpathTV.DecMapUint64Int16V(*vp, true, d)
27832                 if changed {
27833                         *vp = v
27834                 }
27835         } else {
27836                 fastpathTV.DecMapUint64Int16V(rv2i(rv).(map[uint64]int16), false, d)
27837         }
27838 }
27839 func (f fastpathT) DecMapUint64Int16X(vp *map[uint64]int16, d *Decoder) {
27840         v, changed := f.DecMapUint64Int16V(*vp, true, d)
27841         if changed {
27842                 *vp = v
27843         }
27844 }
27845 func (_ fastpathT) DecMapUint64Int16V(v map[uint64]int16, canChange bool,
27846         d *Decoder) (_ map[uint64]int16, changed bool) {
27847         dd, esep := d.d, d.hh.hasElemSeparators()
27848         containerLen := dd.ReadMapStart()
27849         if canChange && v == nil {
27850                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
27851                 v = make(map[uint64]int16, xlen)
27852                 changed = true
27853         }
27854         if containerLen == 0 {
27855                 dd.ReadMapEnd()
27856                 return v, changed
27857         }
27858         d.depthIncr()
27859         var mk uint64
27860         var mv int16
27861         hasLen := containerLen > 0
27862         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27863                 if esep {
27864                         dd.ReadMapElemKey()
27865                 }
27866                 mk = dd.DecodeUint64()
27867                 if esep {
27868                         dd.ReadMapElemValue()
27869                 }
27870                 if dd.TryDecodeAsNil() {
27871                         if v == nil {
27872                         } else if d.h.DeleteOnNilMapValue {
27873                                 delete(v, mk)
27874                         } else {
27875                                 v[mk] = 0
27876                         }
27877                         continue
27878                 }
27879                 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
27880                 if v != nil {
27881                         v[mk] = mv
27882                 }
27883         }
27884         dd.ReadMapEnd()
27885         d.depthDecr()
27886         return v, changed
27887 }
27888
27889 func (d *Decoder) fastpathDecMapUint64Int32R(f *codecFnInfo, rv reflect.Value) {
27890         if rv.Kind() == reflect.Ptr {
27891                 vp := rv2i(rv).(*map[uint64]int32)
27892                 v, changed := fastpathTV.DecMapUint64Int32V(*vp, true, d)
27893                 if changed {
27894                         *vp = v
27895                 }
27896         } else {
27897                 fastpathTV.DecMapUint64Int32V(rv2i(rv).(map[uint64]int32), false, d)
27898         }
27899 }
27900 func (f fastpathT) DecMapUint64Int32X(vp *map[uint64]int32, d *Decoder) {
27901         v, changed := f.DecMapUint64Int32V(*vp, true, d)
27902         if changed {
27903                 *vp = v
27904         }
27905 }
27906 func (_ fastpathT) DecMapUint64Int32V(v map[uint64]int32, canChange bool,
27907         d *Decoder) (_ map[uint64]int32, changed bool) {
27908         dd, esep := d.d, d.hh.hasElemSeparators()
27909         containerLen := dd.ReadMapStart()
27910         if canChange && v == nil {
27911                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
27912                 v = make(map[uint64]int32, xlen)
27913                 changed = true
27914         }
27915         if containerLen == 0 {
27916                 dd.ReadMapEnd()
27917                 return v, changed
27918         }
27919         d.depthIncr()
27920         var mk uint64
27921         var mv int32
27922         hasLen := containerLen > 0
27923         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27924                 if esep {
27925                         dd.ReadMapElemKey()
27926                 }
27927                 mk = dd.DecodeUint64()
27928                 if esep {
27929                         dd.ReadMapElemValue()
27930                 }
27931                 if dd.TryDecodeAsNil() {
27932                         if v == nil {
27933                         } else if d.h.DeleteOnNilMapValue {
27934                                 delete(v, mk)
27935                         } else {
27936                                 v[mk] = 0
27937                         }
27938                         continue
27939                 }
27940                 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
27941                 if v != nil {
27942                         v[mk] = mv
27943                 }
27944         }
27945         dd.ReadMapEnd()
27946         d.depthDecr()
27947         return v, changed
27948 }
27949
27950 func (d *Decoder) fastpathDecMapUint64Int64R(f *codecFnInfo, rv reflect.Value) {
27951         if rv.Kind() == reflect.Ptr {
27952                 vp := rv2i(rv).(*map[uint64]int64)
27953                 v, changed := fastpathTV.DecMapUint64Int64V(*vp, true, d)
27954                 if changed {
27955                         *vp = v
27956                 }
27957         } else {
27958                 fastpathTV.DecMapUint64Int64V(rv2i(rv).(map[uint64]int64), false, d)
27959         }
27960 }
27961 func (f fastpathT) DecMapUint64Int64X(vp *map[uint64]int64, d *Decoder) {
27962         v, changed := f.DecMapUint64Int64V(*vp, true, d)
27963         if changed {
27964                 *vp = v
27965         }
27966 }
27967 func (_ fastpathT) DecMapUint64Int64V(v map[uint64]int64, canChange bool,
27968         d *Decoder) (_ map[uint64]int64, changed bool) {
27969         dd, esep := d.d, d.hh.hasElemSeparators()
27970         containerLen := dd.ReadMapStart()
27971         if canChange && v == nil {
27972                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
27973                 v = make(map[uint64]int64, xlen)
27974                 changed = true
27975         }
27976         if containerLen == 0 {
27977                 dd.ReadMapEnd()
27978                 return v, changed
27979         }
27980         d.depthIncr()
27981         var mk uint64
27982         var mv int64
27983         hasLen := containerLen > 0
27984         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27985                 if esep {
27986                         dd.ReadMapElemKey()
27987                 }
27988                 mk = dd.DecodeUint64()
27989                 if esep {
27990                         dd.ReadMapElemValue()
27991                 }
27992                 if dd.TryDecodeAsNil() {
27993                         if v == nil {
27994                         } else if d.h.DeleteOnNilMapValue {
27995                                 delete(v, mk)
27996                         } else {
27997                                 v[mk] = 0
27998                         }
27999                         continue
28000                 }
28001                 mv = dd.DecodeInt64()
28002                 if v != nil {
28003                         v[mk] = mv
28004                 }
28005         }
28006         dd.ReadMapEnd()
28007         d.depthDecr()
28008         return v, changed
28009 }
28010
28011 func (d *Decoder) fastpathDecMapUint64Float32R(f *codecFnInfo, rv reflect.Value) {
28012         if rv.Kind() == reflect.Ptr {
28013                 vp := rv2i(rv).(*map[uint64]float32)
28014                 v, changed := fastpathTV.DecMapUint64Float32V(*vp, true, d)
28015                 if changed {
28016                         *vp = v
28017                 }
28018         } else {
28019                 fastpathTV.DecMapUint64Float32V(rv2i(rv).(map[uint64]float32), false, d)
28020         }
28021 }
28022 func (f fastpathT) DecMapUint64Float32X(vp *map[uint64]float32, d *Decoder) {
28023         v, changed := f.DecMapUint64Float32V(*vp, true, d)
28024         if changed {
28025                 *vp = v
28026         }
28027 }
28028 func (_ fastpathT) DecMapUint64Float32V(v map[uint64]float32, canChange bool,
28029         d *Decoder) (_ map[uint64]float32, changed bool) {
28030         dd, esep := d.d, d.hh.hasElemSeparators()
28031         containerLen := dd.ReadMapStart()
28032         if canChange && v == nil {
28033                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
28034                 v = make(map[uint64]float32, xlen)
28035                 changed = true
28036         }
28037         if containerLen == 0 {
28038                 dd.ReadMapEnd()
28039                 return v, changed
28040         }
28041         d.depthIncr()
28042         var mk uint64
28043         var mv float32
28044         hasLen := containerLen > 0
28045         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28046                 if esep {
28047                         dd.ReadMapElemKey()
28048                 }
28049                 mk = dd.DecodeUint64()
28050                 if esep {
28051                         dd.ReadMapElemValue()
28052                 }
28053                 if dd.TryDecodeAsNil() {
28054                         if v == nil {
28055                         } else if d.h.DeleteOnNilMapValue {
28056                                 delete(v, mk)
28057                         } else {
28058                                 v[mk] = 0
28059                         }
28060                         continue
28061                 }
28062                 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
28063                 if v != nil {
28064                         v[mk] = mv
28065                 }
28066         }
28067         dd.ReadMapEnd()
28068         d.depthDecr()
28069         return v, changed
28070 }
28071
28072 func (d *Decoder) fastpathDecMapUint64Float64R(f *codecFnInfo, rv reflect.Value) {
28073         if rv.Kind() == reflect.Ptr {
28074                 vp := rv2i(rv).(*map[uint64]float64)
28075                 v, changed := fastpathTV.DecMapUint64Float64V(*vp, true, d)
28076                 if changed {
28077                         *vp = v
28078                 }
28079         } else {
28080                 fastpathTV.DecMapUint64Float64V(rv2i(rv).(map[uint64]float64), false, d)
28081         }
28082 }
28083 func (f fastpathT) DecMapUint64Float64X(vp *map[uint64]float64, d *Decoder) {
28084         v, changed := f.DecMapUint64Float64V(*vp, true, d)
28085         if changed {
28086                 *vp = v
28087         }
28088 }
28089 func (_ fastpathT) DecMapUint64Float64V(v map[uint64]float64, canChange bool,
28090         d *Decoder) (_ map[uint64]float64, changed bool) {
28091         dd, esep := d.d, d.hh.hasElemSeparators()
28092         containerLen := dd.ReadMapStart()
28093         if canChange && v == nil {
28094                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
28095                 v = make(map[uint64]float64, xlen)
28096                 changed = true
28097         }
28098         if containerLen == 0 {
28099                 dd.ReadMapEnd()
28100                 return v, changed
28101         }
28102         d.depthIncr()
28103         var mk uint64
28104         var mv float64
28105         hasLen := containerLen > 0
28106         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28107                 if esep {
28108                         dd.ReadMapElemKey()
28109                 }
28110                 mk = dd.DecodeUint64()
28111                 if esep {
28112                         dd.ReadMapElemValue()
28113                 }
28114                 if dd.TryDecodeAsNil() {
28115                         if v == nil {
28116                         } else if d.h.DeleteOnNilMapValue {
28117                                 delete(v, mk)
28118                         } else {
28119                                 v[mk] = 0
28120                         }
28121                         continue
28122                 }
28123                 mv = dd.DecodeFloat64()
28124                 if v != nil {
28125                         v[mk] = mv
28126                 }
28127         }
28128         dd.ReadMapEnd()
28129         d.depthDecr()
28130         return v, changed
28131 }
28132
28133 func (d *Decoder) fastpathDecMapUint64BoolR(f *codecFnInfo, rv reflect.Value) {
28134         if rv.Kind() == reflect.Ptr {
28135                 vp := rv2i(rv).(*map[uint64]bool)
28136                 v, changed := fastpathTV.DecMapUint64BoolV(*vp, true, d)
28137                 if changed {
28138                         *vp = v
28139                 }
28140         } else {
28141                 fastpathTV.DecMapUint64BoolV(rv2i(rv).(map[uint64]bool), false, d)
28142         }
28143 }
28144 func (f fastpathT) DecMapUint64BoolX(vp *map[uint64]bool, d *Decoder) {
28145         v, changed := f.DecMapUint64BoolV(*vp, true, d)
28146         if changed {
28147                 *vp = v
28148         }
28149 }
28150 func (_ fastpathT) DecMapUint64BoolV(v map[uint64]bool, canChange bool,
28151         d *Decoder) (_ map[uint64]bool, changed bool) {
28152         dd, esep := d.d, d.hh.hasElemSeparators()
28153         containerLen := dd.ReadMapStart()
28154         if canChange && v == nil {
28155                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
28156                 v = make(map[uint64]bool, xlen)
28157                 changed = true
28158         }
28159         if containerLen == 0 {
28160                 dd.ReadMapEnd()
28161                 return v, changed
28162         }
28163         d.depthIncr()
28164         var mk uint64
28165         var mv bool
28166         hasLen := containerLen > 0
28167         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28168                 if esep {
28169                         dd.ReadMapElemKey()
28170                 }
28171                 mk = dd.DecodeUint64()
28172                 if esep {
28173                         dd.ReadMapElemValue()
28174                 }
28175                 if dd.TryDecodeAsNil() {
28176                         if v == nil {
28177                         } else if d.h.DeleteOnNilMapValue {
28178                                 delete(v, mk)
28179                         } else {
28180                                 v[mk] = false
28181                         }
28182                         continue
28183                 }
28184                 mv = dd.DecodeBool()
28185                 if v != nil {
28186                         v[mk] = mv
28187                 }
28188         }
28189         dd.ReadMapEnd()
28190         d.depthDecr()
28191         return v, changed
28192 }
28193
28194 func (d *Decoder) fastpathDecMapUintptrIntfR(f *codecFnInfo, rv reflect.Value) {
28195         if rv.Kind() == reflect.Ptr {
28196                 vp := rv2i(rv).(*map[uintptr]interface{})
28197                 v, changed := fastpathTV.DecMapUintptrIntfV(*vp, true, d)
28198                 if changed {
28199                         *vp = v
28200                 }
28201         } else {
28202                 fastpathTV.DecMapUintptrIntfV(rv2i(rv).(map[uintptr]interface{}), false, d)
28203         }
28204 }
28205 func (f fastpathT) DecMapUintptrIntfX(vp *map[uintptr]interface{}, d *Decoder) {
28206         v, changed := f.DecMapUintptrIntfV(*vp, true, d)
28207         if changed {
28208                 *vp = v
28209         }
28210 }
28211 func (_ fastpathT) DecMapUintptrIntfV(v map[uintptr]interface{}, canChange bool,
28212         d *Decoder) (_ map[uintptr]interface{}, changed bool) {
28213         dd, esep := d.d, d.hh.hasElemSeparators()
28214         containerLen := dd.ReadMapStart()
28215         if canChange && v == nil {
28216                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
28217                 v = make(map[uintptr]interface{}, xlen)
28218                 changed = true
28219         }
28220         if containerLen == 0 {
28221                 dd.ReadMapEnd()
28222                 return v, changed
28223         }
28224         d.depthIncr()
28225         mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
28226         var mk uintptr
28227         var mv interface{}
28228         hasLen := containerLen > 0
28229         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28230                 if esep {
28231                         dd.ReadMapElemKey()
28232                 }
28233                 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28234                 if esep {
28235                         dd.ReadMapElemValue()
28236                 }
28237                 if dd.TryDecodeAsNil() {
28238                         if v == nil {
28239                         } else if d.h.DeleteOnNilMapValue {
28240                                 delete(v, mk)
28241                         } else {
28242                                 v[mk] = nil
28243                         }
28244                         continue
28245                 }
28246                 if mapGet {
28247                         mv = v[mk]
28248                 } else {
28249                         mv = nil
28250                 }
28251                 d.decode(&mv)
28252                 if v != nil {
28253                         v[mk] = mv
28254                 }
28255         }
28256         dd.ReadMapEnd()
28257         d.depthDecr()
28258         return v, changed
28259 }
28260
28261 func (d *Decoder) fastpathDecMapUintptrStringR(f *codecFnInfo, rv reflect.Value) {
28262         if rv.Kind() == reflect.Ptr {
28263                 vp := rv2i(rv).(*map[uintptr]string)
28264                 v, changed := fastpathTV.DecMapUintptrStringV(*vp, true, d)
28265                 if changed {
28266                         *vp = v
28267                 }
28268         } else {
28269                 fastpathTV.DecMapUintptrStringV(rv2i(rv).(map[uintptr]string), false, d)
28270         }
28271 }
28272 func (f fastpathT) DecMapUintptrStringX(vp *map[uintptr]string, d *Decoder) {
28273         v, changed := f.DecMapUintptrStringV(*vp, true, d)
28274         if changed {
28275                 *vp = v
28276         }
28277 }
28278 func (_ fastpathT) DecMapUintptrStringV(v map[uintptr]string, canChange bool,
28279         d *Decoder) (_ map[uintptr]string, changed bool) {
28280         dd, esep := d.d, d.hh.hasElemSeparators()
28281         containerLen := dd.ReadMapStart()
28282         if canChange && v == nil {
28283                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
28284                 v = make(map[uintptr]string, xlen)
28285                 changed = true
28286         }
28287         if containerLen == 0 {
28288                 dd.ReadMapEnd()
28289                 return v, changed
28290         }
28291         d.depthIncr()
28292         var mk uintptr
28293         var mv string
28294         hasLen := containerLen > 0
28295         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28296                 if esep {
28297                         dd.ReadMapElemKey()
28298                 }
28299                 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28300                 if esep {
28301                         dd.ReadMapElemValue()
28302                 }
28303                 if dd.TryDecodeAsNil() {
28304                         if v == nil {
28305                         } else if d.h.DeleteOnNilMapValue {
28306                                 delete(v, mk)
28307                         } else {
28308                                 v[mk] = ""
28309                         }
28310                         continue
28311                 }
28312                 mv = dd.DecodeString()
28313                 if v != nil {
28314                         v[mk] = mv
28315                 }
28316         }
28317         dd.ReadMapEnd()
28318         d.depthDecr()
28319         return v, changed
28320 }
28321
28322 func (d *Decoder) fastpathDecMapUintptrUintR(f *codecFnInfo, rv reflect.Value) {
28323         if rv.Kind() == reflect.Ptr {
28324                 vp := rv2i(rv).(*map[uintptr]uint)
28325                 v, changed := fastpathTV.DecMapUintptrUintV(*vp, true, d)
28326                 if changed {
28327                         *vp = v
28328                 }
28329         } else {
28330                 fastpathTV.DecMapUintptrUintV(rv2i(rv).(map[uintptr]uint), false, d)
28331         }
28332 }
28333 func (f fastpathT) DecMapUintptrUintX(vp *map[uintptr]uint, d *Decoder) {
28334         v, changed := f.DecMapUintptrUintV(*vp, true, d)
28335         if changed {
28336                 *vp = v
28337         }
28338 }
28339 func (_ fastpathT) DecMapUintptrUintV(v map[uintptr]uint, canChange bool,
28340         d *Decoder) (_ map[uintptr]uint, changed bool) {
28341         dd, esep := d.d, d.hh.hasElemSeparators()
28342         containerLen := dd.ReadMapStart()
28343         if canChange && v == nil {
28344                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
28345                 v = make(map[uintptr]uint, xlen)
28346                 changed = true
28347         }
28348         if containerLen == 0 {
28349                 dd.ReadMapEnd()
28350                 return v, changed
28351         }
28352         d.depthIncr()
28353         var mk uintptr
28354         var mv uint
28355         hasLen := containerLen > 0
28356         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28357                 if esep {
28358                         dd.ReadMapElemKey()
28359                 }
28360                 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28361                 if esep {
28362                         dd.ReadMapElemValue()
28363                 }
28364                 if dd.TryDecodeAsNil() {
28365                         if v == nil {
28366                         } else if d.h.DeleteOnNilMapValue {
28367                                 delete(v, mk)
28368                         } else {
28369                                 v[mk] = 0
28370                         }
28371                         continue
28372                 }
28373                 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28374                 if v != nil {
28375                         v[mk] = mv
28376                 }
28377         }
28378         dd.ReadMapEnd()
28379         d.depthDecr()
28380         return v, changed
28381 }
28382
28383 func (d *Decoder) fastpathDecMapUintptrUint8R(f *codecFnInfo, rv reflect.Value) {
28384         if rv.Kind() == reflect.Ptr {
28385                 vp := rv2i(rv).(*map[uintptr]uint8)
28386                 v, changed := fastpathTV.DecMapUintptrUint8V(*vp, true, d)
28387                 if changed {
28388                         *vp = v
28389                 }
28390         } else {
28391                 fastpathTV.DecMapUintptrUint8V(rv2i(rv).(map[uintptr]uint8), false, d)
28392         }
28393 }
28394 func (f fastpathT) DecMapUintptrUint8X(vp *map[uintptr]uint8, d *Decoder) {
28395         v, changed := f.DecMapUintptrUint8V(*vp, true, d)
28396         if changed {
28397                 *vp = v
28398         }
28399 }
28400 func (_ fastpathT) DecMapUintptrUint8V(v map[uintptr]uint8, canChange bool,
28401         d *Decoder) (_ map[uintptr]uint8, changed bool) {
28402         dd, esep := d.d, d.hh.hasElemSeparators()
28403         containerLen := dd.ReadMapStart()
28404         if canChange && v == nil {
28405                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
28406                 v = make(map[uintptr]uint8, xlen)
28407                 changed = true
28408         }
28409         if containerLen == 0 {
28410                 dd.ReadMapEnd()
28411                 return v, changed
28412         }
28413         d.depthIncr()
28414         var mk uintptr
28415         var mv uint8
28416         hasLen := containerLen > 0
28417         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28418                 if esep {
28419                         dd.ReadMapElemKey()
28420                 }
28421                 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28422                 if esep {
28423                         dd.ReadMapElemValue()
28424                 }
28425                 if dd.TryDecodeAsNil() {
28426                         if v == nil {
28427                         } else if d.h.DeleteOnNilMapValue {
28428                                 delete(v, mk)
28429                         } else {
28430                                 v[mk] = 0
28431                         }
28432                         continue
28433                 }
28434                 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
28435                 if v != nil {
28436                         v[mk] = mv
28437                 }
28438         }
28439         dd.ReadMapEnd()
28440         d.depthDecr()
28441         return v, changed
28442 }
28443
28444 func (d *Decoder) fastpathDecMapUintptrUint16R(f *codecFnInfo, rv reflect.Value) {
28445         if rv.Kind() == reflect.Ptr {
28446                 vp := rv2i(rv).(*map[uintptr]uint16)
28447                 v, changed := fastpathTV.DecMapUintptrUint16V(*vp, true, d)
28448                 if changed {
28449                         *vp = v
28450                 }
28451         } else {
28452                 fastpathTV.DecMapUintptrUint16V(rv2i(rv).(map[uintptr]uint16), false, d)
28453         }
28454 }
28455 func (f fastpathT) DecMapUintptrUint16X(vp *map[uintptr]uint16, d *Decoder) {
28456         v, changed := f.DecMapUintptrUint16V(*vp, true, d)
28457         if changed {
28458                 *vp = v
28459         }
28460 }
28461 func (_ fastpathT) DecMapUintptrUint16V(v map[uintptr]uint16, canChange bool,
28462         d *Decoder) (_ map[uintptr]uint16, changed bool) {
28463         dd, esep := d.d, d.hh.hasElemSeparators()
28464         containerLen := dd.ReadMapStart()
28465         if canChange && v == nil {
28466                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
28467                 v = make(map[uintptr]uint16, xlen)
28468                 changed = true
28469         }
28470         if containerLen == 0 {
28471                 dd.ReadMapEnd()
28472                 return v, changed
28473         }
28474         d.depthIncr()
28475         var mk uintptr
28476         var mv uint16
28477         hasLen := containerLen > 0
28478         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28479                 if esep {
28480                         dd.ReadMapElemKey()
28481                 }
28482                 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28483                 if esep {
28484                         dd.ReadMapElemValue()
28485                 }
28486                 if dd.TryDecodeAsNil() {
28487                         if v == nil {
28488                         } else if d.h.DeleteOnNilMapValue {
28489                                 delete(v, mk)
28490                         } else {
28491                                 v[mk] = 0
28492                         }
28493                         continue
28494                 }
28495                 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
28496                 if v != nil {
28497                         v[mk] = mv
28498                 }
28499         }
28500         dd.ReadMapEnd()
28501         d.depthDecr()
28502         return v, changed
28503 }
28504
28505 func (d *Decoder) fastpathDecMapUintptrUint32R(f *codecFnInfo, rv reflect.Value) {
28506         if rv.Kind() == reflect.Ptr {
28507                 vp := rv2i(rv).(*map[uintptr]uint32)
28508                 v, changed := fastpathTV.DecMapUintptrUint32V(*vp, true, d)
28509                 if changed {
28510                         *vp = v
28511                 }
28512         } else {
28513                 fastpathTV.DecMapUintptrUint32V(rv2i(rv).(map[uintptr]uint32), false, d)
28514         }
28515 }
28516 func (f fastpathT) DecMapUintptrUint32X(vp *map[uintptr]uint32, d *Decoder) {
28517         v, changed := f.DecMapUintptrUint32V(*vp, true, d)
28518         if changed {
28519                 *vp = v
28520         }
28521 }
28522 func (_ fastpathT) DecMapUintptrUint32V(v map[uintptr]uint32, canChange bool,
28523         d *Decoder) (_ map[uintptr]uint32, changed bool) {
28524         dd, esep := d.d, d.hh.hasElemSeparators()
28525         containerLen := dd.ReadMapStart()
28526         if canChange && v == nil {
28527                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
28528                 v = make(map[uintptr]uint32, xlen)
28529                 changed = true
28530         }
28531         if containerLen == 0 {
28532                 dd.ReadMapEnd()
28533                 return v, changed
28534         }
28535         d.depthIncr()
28536         var mk uintptr
28537         var mv uint32
28538         hasLen := containerLen > 0
28539         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28540                 if esep {
28541                         dd.ReadMapElemKey()
28542                 }
28543                 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28544                 if esep {
28545                         dd.ReadMapElemValue()
28546                 }
28547                 if dd.TryDecodeAsNil() {
28548                         if v == nil {
28549                         } else if d.h.DeleteOnNilMapValue {
28550                                 delete(v, mk)
28551                         } else {
28552                                 v[mk] = 0
28553                         }
28554                         continue
28555                 }
28556                 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
28557                 if v != nil {
28558                         v[mk] = mv
28559                 }
28560         }
28561         dd.ReadMapEnd()
28562         d.depthDecr()
28563         return v, changed
28564 }
28565
28566 func (d *Decoder) fastpathDecMapUintptrUint64R(f *codecFnInfo, rv reflect.Value) {
28567         if rv.Kind() == reflect.Ptr {
28568                 vp := rv2i(rv).(*map[uintptr]uint64)
28569                 v, changed := fastpathTV.DecMapUintptrUint64V(*vp, true, d)
28570                 if changed {
28571                         *vp = v
28572                 }
28573         } else {
28574                 fastpathTV.DecMapUintptrUint64V(rv2i(rv).(map[uintptr]uint64), false, d)
28575         }
28576 }
28577 func (f fastpathT) DecMapUintptrUint64X(vp *map[uintptr]uint64, d *Decoder) {
28578         v, changed := f.DecMapUintptrUint64V(*vp, true, d)
28579         if changed {
28580                 *vp = v
28581         }
28582 }
28583 func (_ fastpathT) DecMapUintptrUint64V(v map[uintptr]uint64, canChange bool,
28584         d *Decoder) (_ map[uintptr]uint64, changed bool) {
28585         dd, esep := d.d, d.hh.hasElemSeparators()
28586         containerLen := dd.ReadMapStart()
28587         if canChange && v == nil {
28588                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
28589                 v = make(map[uintptr]uint64, xlen)
28590                 changed = true
28591         }
28592         if containerLen == 0 {
28593                 dd.ReadMapEnd()
28594                 return v, changed
28595         }
28596         d.depthIncr()
28597         var mk uintptr
28598         var mv uint64
28599         hasLen := containerLen > 0
28600         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28601                 if esep {
28602                         dd.ReadMapElemKey()
28603                 }
28604                 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28605                 if esep {
28606                         dd.ReadMapElemValue()
28607                 }
28608                 if dd.TryDecodeAsNil() {
28609                         if v == nil {
28610                         } else if d.h.DeleteOnNilMapValue {
28611                                 delete(v, mk)
28612                         } else {
28613                                 v[mk] = 0
28614                         }
28615                         continue
28616                 }
28617                 mv = dd.DecodeUint64()
28618                 if v != nil {
28619                         v[mk] = mv
28620                 }
28621         }
28622         dd.ReadMapEnd()
28623         d.depthDecr()
28624         return v, changed
28625 }
28626
28627 func (d *Decoder) fastpathDecMapUintptrUintptrR(f *codecFnInfo, rv reflect.Value) {
28628         if rv.Kind() == reflect.Ptr {
28629                 vp := rv2i(rv).(*map[uintptr]uintptr)
28630                 v, changed := fastpathTV.DecMapUintptrUintptrV(*vp, true, d)
28631                 if changed {
28632                         *vp = v
28633                 }
28634         } else {
28635                 fastpathTV.DecMapUintptrUintptrV(rv2i(rv).(map[uintptr]uintptr), false, d)
28636         }
28637 }
28638 func (f fastpathT) DecMapUintptrUintptrX(vp *map[uintptr]uintptr, d *Decoder) {
28639         v, changed := f.DecMapUintptrUintptrV(*vp, true, d)
28640         if changed {
28641                 *vp = v
28642         }
28643 }
28644 func (_ fastpathT) DecMapUintptrUintptrV(v map[uintptr]uintptr, canChange bool,
28645         d *Decoder) (_ map[uintptr]uintptr, changed bool) {
28646         dd, esep := d.d, d.hh.hasElemSeparators()
28647         containerLen := dd.ReadMapStart()
28648         if canChange && v == nil {
28649                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
28650                 v = make(map[uintptr]uintptr, xlen)
28651                 changed = true
28652         }
28653         if containerLen == 0 {
28654                 dd.ReadMapEnd()
28655                 return v, changed
28656         }
28657         d.depthIncr()
28658         var mk uintptr
28659         var mv uintptr
28660         hasLen := containerLen > 0
28661         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28662                 if esep {
28663                         dd.ReadMapElemKey()
28664                 }
28665                 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28666                 if esep {
28667                         dd.ReadMapElemValue()
28668                 }
28669                 if dd.TryDecodeAsNil() {
28670                         if v == nil {
28671                         } else if d.h.DeleteOnNilMapValue {
28672                                 delete(v, mk)
28673                         } else {
28674                                 v[mk] = 0
28675                         }
28676                         continue
28677                 }
28678                 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28679                 if v != nil {
28680                         v[mk] = mv
28681                 }
28682         }
28683         dd.ReadMapEnd()
28684         d.depthDecr()
28685         return v, changed
28686 }
28687
28688 func (d *Decoder) fastpathDecMapUintptrIntR(f *codecFnInfo, rv reflect.Value) {
28689         if rv.Kind() == reflect.Ptr {
28690                 vp := rv2i(rv).(*map[uintptr]int)
28691                 v, changed := fastpathTV.DecMapUintptrIntV(*vp, true, d)
28692                 if changed {
28693                         *vp = v
28694                 }
28695         } else {
28696                 fastpathTV.DecMapUintptrIntV(rv2i(rv).(map[uintptr]int), false, d)
28697         }
28698 }
28699 func (f fastpathT) DecMapUintptrIntX(vp *map[uintptr]int, d *Decoder) {
28700         v, changed := f.DecMapUintptrIntV(*vp, true, d)
28701         if changed {
28702                 *vp = v
28703         }
28704 }
28705 func (_ fastpathT) DecMapUintptrIntV(v map[uintptr]int, canChange bool,
28706         d *Decoder) (_ map[uintptr]int, changed bool) {
28707         dd, esep := d.d, d.hh.hasElemSeparators()
28708         containerLen := dd.ReadMapStart()
28709         if canChange && v == nil {
28710                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
28711                 v = make(map[uintptr]int, xlen)
28712                 changed = true
28713         }
28714         if containerLen == 0 {
28715                 dd.ReadMapEnd()
28716                 return v, changed
28717         }
28718         d.depthIncr()
28719         var mk uintptr
28720         var mv int
28721         hasLen := containerLen > 0
28722         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28723                 if esep {
28724                         dd.ReadMapElemKey()
28725                 }
28726                 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28727                 if esep {
28728                         dd.ReadMapElemValue()
28729                 }
28730                 if dd.TryDecodeAsNil() {
28731                         if v == nil {
28732                         } else if d.h.DeleteOnNilMapValue {
28733                                 delete(v, mk)
28734                         } else {
28735                                 v[mk] = 0
28736                         }
28737                         continue
28738                 }
28739                 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
28740                 if v != nil {
28741                         v[mk] = mv
28742                 }
28743         }
28744         dd.ReadMapEnd()
28745         d.depthDecr()
28746         return v, changed
28747 }
28748
28749 func (d *Decoder) fastpathDecMapUintptrInt8R(f *codecFnInfo, rv reflect.Value) {
28750         if rv.Kind() == reflect.Ptr {
28751                 vp := rv2i(rv).(*map[uintptr]int8)
28752                 v, changed := fastpathTV.DecMapUintptrInt8V(*vp, true, d)
28753                 if changed {
28754                         *vp = v
28755                 }
28756         } else {
28757                 fastpathTV.DecMapUintptrInt8V(rv2i(rv).(map[uintptr]int8), false, d)
28758         }
28759 }
28760 func (f fastpathT) DecMapUintptrInt8X(vp *map[uintptr]int8, d *Decoder) {
28761         v, changed := f.DecMapUintptrInt8V(*vp, true, d)
28762         if changed {
28763                 *vp = v
28764         }
28765 }
28766 func (_ fastpathT) DecMapUintptrInt8V(v map[uintptr]int8, canChange bool,
28767         d *Decoder) (_ map[uintptr]int8, changed bool) {
28768         dd, esep := d.d, d.hh.hasElemSeparators()
28769         containerLen := dd.ReadMapStart()
28770         if canChange && v == nil {
28771                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
28772                 v = make(map[uintptr]int8, xlen)
28773                 changed = true
28774         }
28775         if containerLen == 0 {
28776                 dd.ReadMapEnd()
28777                 return v, changed
28778         }
28779         d.depthIncr()
28780         var mk uintptr
28781         var mv int8
28782         hasLen := containerLen > 0
28783         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28784                 if esep {
28785                         dd.ReadMapElemKey()
28786                 }
28787                 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28788                 if esep {
28789                         dd.ReadMapElemValue()
28790                 }
28791                 if dd.TryDecodeAsNil() {
28792                         if v == nil {
28793                         } else if d.h.DeleteOnNilMapValue {
28794                                 delete(v, mk)
28795                         } else {
28796                                 v[mk] = 0
28797                         }
28798                         continue
28799                 }
28800                 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
28801                 if v != nil {
28802                         v[mk] = mv
28803                 }
28804         }
28805         dd.ReadMapEnd()
28806         d.depthDecr()
28807         return v, changed
28808 }
28809
28810 func (d *Decoder) fastpathDecMapUintptrInt16R(f *codecFnInfo, rv reflect.Value) {
28811         if rv.Kind() == reflect.Ptr {
28812                 vp := rv2i(rv).(*map[uintptr]int16)
28813                 v, changed := fastpathTV.DecMapUintptrInt16V(*vp, true, d)
28814                 if changed {
28815                         *vp = v
28816                 }
28817         } else {
28818                 fastpathTV.DecMapUintptrInt16V(rv2i(rv).(map[uintptr]int16), false, d)
28819         }
28820 }
28821 func (f fastpathT) DecMapUintptrInt16X(vp *map[uintptr]int16, d *Decoder) {
28822         v, changed := f.DecMapUintptrInt16V(*vp, true, d)
28823         if changed {
28824                 *vp = v
28825         }
28826 }
28827 func (_ fastpathT) DecMapUintptrInt16V(v map[uintptr]int16, canChange bool,
28828         d *Decoder) (_ map[uintptr]int16, changed bool) {
28829         dd, esep := d.d, d.hh.hasElemSeparators()
28830         containerLen := dd.ReadMapStart()
28831         if canChange && v == nil {
28832                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
28833                 v = make(map[uintptr]int16, xlen)
28834                 changed = true
28835         }
28836         if containerLen == 0 {
28837                 dd.ReadMapEnd()
28838                 return v, changed
28839         }
28840         d.depthIncr()
28841         var mk uintptr
28842         var mv int16
28843         hasLen := containerLen > 0
28844         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28845                 if esep {
28846                         dd.ReadMapElemKey()
28847                 }
28848                 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28849                 if esep {
28850                         dd.ReadMapElemValue()
28851                 }
28852                 if dd.TryDecodeAsNil() {
28853                         if v == nil {
28854                         } else if d.h.DeleteOnNilMapValue {
28855                                 delete(v, mk)
28856                         } else {
28857                                 v[mk] = 0
28858                         }
28859                         continue
28860                 }
28861                 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
28862                 if v != nil {
28863                         v[mk] = mv
28864                 }
28865         }
28866         dd.ReadMapEnd()
28867         d.depthDecr()
28868         return v, changed
28869 }
28870
28871 func (d *Decoder) fastpathDecMapUintptrInt32R(f *codecFnInfo, rv reflect.Value) {
28872         if rv.Kind() == reflect.Ptr {
28873                 vp := rv2i(rv).(*map[uintptr]int32)
28874                 v, changed := fastpathTV.DecMapUintptrInt32V(*vp, true, d)
28875                 if changed {
28876                         *vp = v
28877                 }
28878         } else {
28879                 fastpathTV.DecMapUintptrInt32V(rv2i(rv).(map[uintptr]int32), false, d)
28880         }
28881 }
28882 func (f fastpathT) DecMapUintptrInt32X(vp *map[uintptr]int32, d *Decoder) {
28883         v, changed := f.DecMapUintptrInt32V(*vp, true, d)
28884         if changed {
28885                 *vp = v
28886         }
28887 }
28888 func (_ fastpathT) DecMapUintptrInt32V(v map[uintptr]int32, canChange bool,
28889         d *Decoder) (_ map[uintptr]int32, changed bool) {
28890         dd, esep := d.d, d.hh.hasElemSeparators()
28891         containerLen := dd.ReadMapStart()
28892         if canChange && v == nil {
28893                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
28894                 v = make(map[uintptr]int32, xlen)
28895                 changed = true
28896         }
28897         if containerLen == 0 {
28898                 dd.ReadMapEnd()
28899                 return v, changed
28900         }
28901         d.depthIncr()
28902         var mk uintptr
28903         var mv int32
28904         hasLen := containerLen > 0
28905         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28906                 if esep {
28907                         dd.ReadMapElemKey()
28908                 }
28909                 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28910                 if esep {
28911                         dd.ReadMapElemValue()
28912                 }
28913                 if dd.TryDecodeAsNil() {
28914                         if v == nil {
28915                         } else if d.h.DeleteOnNilMapValue {
28916                                 delete(v, mk)
28917                         } else {
28918                                 v[mk] = 0
28919                         }
28920                         continue
28921                 }
28922                 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
28923                 if v != nil {
28924                         v[mk] = mv
28925                 }
28926         }
28927         dd.ReadMapEnd()
28928         d.depthDecr()
28929         return v, changed
28930 }
28931
28932 func (d *Decoder) fastpathDecMapUintptrInt64R(f *codecFnInfo, rv reflect.Value) {
28933         if rv.Kind() == reflect.Ptr {
28934                 vp := rv2i(rv).(*map[uintptr]int64)
28935                 v, changed := fastpathTV.DecMapUintptrInt64V(*vp, true, d)
28936                 if changed {
28937                         *vp = v
28938                 }
28939         } else {
28940                 fastpathTV.DecMapUintptrInt64V(rv2i(rv).(map[uintptr]int64), false, d)
28941         }
28942 }
28943 func (f fastpathT) DecMapUintptrInt64X(vp *map[uintptr]int64, d *Decoder) {
28944         v, changed := f.DecMapUintptrInt64V(*vp, true, d)
28945         if changed {
28946                 *vp = v
28947         }
28948 }
28949 func (_ fastpathT) DecMapUintptrInt64V(v map[uintptr]int64, canChange bool,
28950         d *Decoder) (_ map[uintptr]int64, changed bool) {
28951         dd, esep := d.d, d.hh.hasElemSeparators()
28952         containerLen := dd.ReadMapStart()
28953         if canChange && v == nil {
28954                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
28955                 v = make(map[uintptr]int64, xlen)
28956                 changed = true
28957         }
28958         if containerLen == 0 {
28959                 dd.ReadMapEnd()
28960                 return v, changed
28961         }
28962         d.depthIncr()
28963         var mk uintptr
28964         var mv int64
28965         hasLen := containerLen > 0
28966         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28967                 if esep {
28968                         dd.ReadMapElemKey()
28969                 }
28970                 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28971                 if esep {
28972                         dd.ReadMapElemValue()
28973                 }
28974                 if dd.TryDecodeAsNil() {
28975                         if v == nil {
28976                         } else if d.h.DeleteOnNilMapValue {
28977                                 delete(v, mk)
28978                         } else {
28979                                 v[mk] = 0
28980                         }
28981                         continue
28982                 }
28983                 mv = dd.DecodeInt64()
28984                 if v != nil {
28985                         v[mk] = mv
28986                 }
28987         }
28988         dd.ReadMapEnd()
28989         d.depthDecr()
28990         return v, changed
28991 }
28992
28993 func (d *Decoder) fastpathDecMapUintptrFloat32R(f *codecFnInfo, rv reflect.Value) {
28994         if rv.Kind() == reflect.Ptr {
28995                 vp := rv2i(rv).(*map[uintptr]float32)
28996                 v, changed := fastpathTV.DecMapUintptrFloat32V(*vp, true, d)
28997                 if changed {
28998                         *vp = v
28999                 }
29000         } else {
29001                 fastpathTV.DecMapUintptrFloat32V(rv2i(rv).(map[uintptr]float32), false, d)
29002         }
29003 }
29004 func (f fastpathT) DecMapUintptrFloat32X(vp *map[uintptr]float32, d *Decoder) {
29005         v, changed := f.DecMapUintptrFloat32V(*vp, true, d)
29006         if changed {
29007                 *vp = v
29008         }
29009 }
29010 func (_ fastpathT) DecMapUintptrFloat32V(v map[uintptr]float32, canChange bool,
29011         d *Decoder) (_ map[uintptr]float32, changed bool) {
29012         dd, esep := d.d, d.hh.hasElemSeparators()
29013         containerLen := dd.ReadMapStart()
29014         if canChange && v == nil {
29015                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
29016                 v = make(map[uintptr]float32, xlen)
29017                 changed = true
29018         }
29019         if containerLen == 0 {
29020                 dd.ReadMapEnd()
29021                 return v, changed
29022         }
29023         d.depthIncr()
29024         var mk uintptr
29025         var mv float32
29026         hasLen := containerLen > 0
29027         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29028                 if esep {
29029                         dd.ReadMapElemKey()
29030                 }
29031                 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
29032                 if esep {
29033                         dd.ReadMapElemValue()
29034                 }
29035                 if dd.TryDecodeAsNil() {
29036                         if v == nil {
29037                         } else if d.h.DeleteOnNilMapValue {
29038                                 delete(v, mk)
29039                         } else {
29040                                 v[mk] = 0
29041                         }
29042                         continue
29043                 }
29044                 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
29045                 if v != nil {
29046                         v[mk] = mv
29047                 }
29048         }
29049         dd.ReadMapEnd()
29050         d.depthDecr()
29051         return v, changed
29052 }
29053
29054 func (d *Decoder) fastpathDecMapUintptrFloat64R(f *codecFnInfo, rv reflect.Value) {
29055         if rv.Kind() == reflect.Ptr {
29056                 vp := rv2i(rv).(*map[uintptr]float64)
29057                 v, changed := fastpathTV.DecMapUintptrFloat64V(*vp, true, d)
29058                 if changed {
29059                         *vp = v
29060                 }
29061         } else {
29062                 fastpathTV.DecMapUintptrFloat64V(rv2i(rv).(map[uintptr]float64), false, d)
29063         }
29064 }
29065 func (f fastpathT) DecMapUintptrFloat64X(vp *map[uintptr]float64, d *Decoder) {
29066         v, changed := f.DecMapUintptrFloat64V(*vp, true, d)
29067         if changed {
29068                 *vp = v
29069         }
29070 }
29071 func (_ fastpathT) DecMapUintptrFloat64V(v map[uintptr]float64, canChange bool,
29072         d *Decoder) (_ map[uintptr]float64, changed bool) {
29073         dd, esep := d.d, d.hh.hasElemSeparators()
29074         containerLen := dd.ReadMapStart()
29075         if canChange && v == nil {
29076                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
29077                 v = make(map[uintptr]float64, xlen)
29078                 changed = true
29079         }
29080         if containerLen == 0 {
29081                 dd.ReadMapEnd()
29082                 return v, changed
29083         }
29084         d.depthIncr()
29085         var mk uintptr
29086         var mv float64
29087         hasLen := containerLen > 0
29088         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29089                 if esep {
29090                         dd.ReadMapElemKey()
29091                 }
29092                 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
29093                 if esep {
29094                         dd.ReadMapElemValue()
29095                 }
29096                 if dd.TryDecodeAsNil() {
29097                         if v == nil {
29098                         } else if d.h.DeleteOnNilMapValue {
29099                                 delete(v, mk)
29100                         } else {
29101                                 v[mk] = 0
29102                         }
29103                         continue
29104                 }
29105                 mv = dd.DecodeFloat64()
29106                 if v != nil {
29107                         v[mk] = mv
29108                 }
29109         }
29110         dd.ReadMapEnd()
29111         d.depthDecr()
29112         return v, changed
29113 }
29114
29115 func (d *Decoder) fastpathDecMapUintptrBoolR(f *codecFnInfo, rv reflect.Value) {
29116         if rv.Kind() == reflect.Ptr {
29117                 vp := rv2i(rv).(*map[uintptr]bool)
29118                 v, changed := fastpathTV.DecMapUintptrBoolV(*vp, true, d)
29119                 if changed {
29120                         *vp = v
29121                 }
29122         } else {
29123                 fastpathTV.DecMapUintptrBoolV(rv2i(rv).(map[uintptr]bool), false, d)
29124         }
29125 }
29126 func (f fastpathT) DecMapUintptrBoolX(vp *map[uintptr]bool, d *Decoder) {
29127         v, changed := f.DecMapUintptrBoolV(*vp, true, d)
29128         if changed {
29129                 *vp = v
29130         }
29131 }
29132 func (_ fastpathT) DecMapUintptrBoolV(v map[uintptr]bool, canChange bool,
29133         d *Decoder) (_ map[uintptr]bool, changed bool) {
29134         dd, esep := d.d, d.hh.hasElemSeparators()
29135         containerLen := dd.ReadMapStart()
29136         if canChange && v == nil {
29137                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
29138                 v = make(map[uintptr]bool, xlen)
29139                 changed = true
29140         }
29141         if containerLen == 0 {
29142                 dd.ReadMapEnd()
29143                 return v, changed
29144         }
29145         d.depthIncr()
29146         var mk uintptr
29147         var mv bool
29148         hasLen := containerLen > 0
29149         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29150                 if esep {
29151                         dd.ReadMapElemKey()
29152                 }
29153                 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
29154                 if esep {
29155                         dd.ReadMapElemValue()
29156                 }
29157                 if dd.TryDecodeAsNil() {
29158                         if v == nil {
29159                         } else if d.h.DeleteOnNilMapValue {
29160                                 delete(v, mk)
29161                         } else {
29162                                 v[mk] = false
29163                         }
29164                         continue
29165                 }
29166                 mv = dd.DecodeBool()
29167                 if v != nil {
29168                         v[mk] = mv
29169                 }
29170         }
29171         dd.ReadMapEnd()
29172         d.depthDecr()
29173         return v, changed
29174 }
29175
29176 func (d *Decoder) fastpathDecMapIntIntfR(f *codecFnInfo, rv reflect.Value) {
29177         if rv.Kind() == reflect.Ptr {
29178                 vp := rv2i(rv).(*map[int]interface{})
29179                 v, changed := fastpathTV.DecMapIntIntfV(*vp, true, d)
29180                 if changed {
29181                         *vp = v
29182                 }
29183         } else {
29184                 fastpathTV.DecMapIntIntfV(rv2i(rv).(map[int]interface{}), false, d)
29185         }
29186 }
29187 func (f fastpathT) DecMapIntIntfX(vp *map[int]interface{}, d *Decoder) {
29188         v, changed := f.DecMapIntIntfV(*vp, true, d)
29189         if changed {
29190                 *vp = v
29191         }
29192 }
29193 func (_ fastpathT) DecMapIntIntfV(v map[int]interface{}, canChange bool,
29194         d *Decoder) (_ map[int]interface{}, changed bool) {
29195         dd, esep := d.d, d.hh.hasElemSeparators()
29196         containerLen := dd.ReadMapStart()
29197         if canChange && v == nil {
29198                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
29199                 v = make(map[int]interface{}, xlen)
29200                 changed = true
29201         }
29202         if containerLen == 0 {
29203                 dd.ReadMapEnd()
29204                 return v, changed
29205         }
29206         d.depthIncr()
29207         mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
29208         var mk int
29209         var mv interface{}
29210         hasLen := containerLen > 0
29211         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29212                 if esep {
29213                         dd.ReadMapElemKey()
29214                 }
29215                 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29216                 if esep {
29217                         dd.ReadMapElemValue()
29218                 }
29219                 if dd.TryDecodeAsNil() {
29220                         if v == nil {
29221                         } else if d.h.DeleteOnNilMapValue {
29222                                 delete(v, mk)
29223                         } else {
29224                                 v[mk] = nil
29225                         }
29226                         continue
29227                 }
29228                 if mapGet {
29229                         mv = v[mk]
29230                 } else {
29231                         mv = nil
29232                 }
29233                 d.decode(&mv)
29234                 if v != nil {
29235                         v[mk] = mv
29236                 }
29237         }
29238         dd.ReadMapEnd()
29239         d.depthDecr()
29240         return v, changed
29241 }
29242
29243 func (d *Decoder) fastpathDecMapIntStringR(f *codecFnInfo, rv reflect.Value) {
29244         if rv.Kind() == reflect.Ptr {
29245                 vp := rv2i(rv).(*map[int]string)
29246                 v, changed := fastpathTV.DecMapIntStringV(*vp, true, d)
29247                 if changed {
29248                         *vp = v
29249                 }
29250         } else {
29251                 fastpathTV.DecMapIntStringV(rv2i(rv).(map[int]string), false, d)
29252         }
29253 }
29254 func (f fastpathT) DecMapIntStringX(vp *map[int]string, d *Decoder) {
29255         v, changed := f.DecMapIntStringV(*vp, true, d)
29256         if changed {
29257                 *vp = v
29258         }
29259 }
29260 func (_ fastpathT) DecMapIntStringV(v map[int]string, canChange bool,
29261         d *Decoder) (_ map[int]string, changed bool) {
29262         dd, esep := d.d, d.hh.hasElemSeparators()
29263         containerLen := dd.ReadMapStart()
29264         if canChange && v == nil {
29265                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
29266                 v = make(map[int]string, xlen)
29267                 changed = true
29268         }
29269         if containerLen == 0 {
29270                 dd.ReadMapEnd()
29271                 return v, changed
29272         }
29273         d.depthIncr()
29274         var mk int
29275         var mv string
29276         hasLen := containerLen > 0
29277         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29278                 if esep {
29279                         dd.ReadMapElemKey()
29280                 }
29281                 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29282                 if esep {
29283                         dd.ReadMapElemValue()
29284                 }
29285                 if dd.TryDecodeAsNil() {
29286                         if v == nil {
29287                         } else if d.h.DeleteOnNilMapValue {
29288                                 delete(v, mk)
29289                         } else {
29290                                 v[mk] = ""
29291                         }
29292                         continue
29293                 }
29294                 mv = dd.DecodeString()
29295                 if v != nil {
29296                         v[mk] = mv
29297                 }
29298         }
29299         dd.ReadMapEnd()
29300         d.depthDecr()
29301         return v, changed
29302 }
29303
29304 func (d *Decoder) fastpathDecMapIntUintR(f *codecFnInfo, rv reflect.Value) {
29305         if rv.Kind() == reflect.Ptr {
29306                 vp := rv2i(rv).(*map[int]uint)
29307                 v, changed := fastpathTV.DecMapIntUintV(*vp, true, d)
29308                 if changed {
29309                         *vp = v
29310                 }
29311         } else {
29312                 fastpathTV.DecMapIntUintV(rv2i(rv).(map[int]uint), false, d)
29313         }
29314 }
29315 func (f fastpathT) DecMapIntUintX(vp *map[int]uint, d *Decoder) {
29316         v, changed := f.DecMapIntUintV(*vp, true, d)
29317         if changed {
29318                 *vp = v
29319         }
29320 }
29321 func (_ fastpathT) DecMapIntUintV(v map[int]uint, canChange bool,
29322         d *Decoder) (_ map[int]uint, changed bool) {
29323         dd, esep := d.d, d.hh.hasElemSeparators()
29324         containerLen := dd.ReadMapStart()
29325         if canChange && v == nil {
29326                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
29327                 v = make(map[int]uint, xlen)
29328                 changed = true
29329         }
29330         if containerLen == 0 {
29331                 dd.ReadMapEnd()
29332                 return v, changed
29333         }
29334         d.depthIncr()
29335         var mk int
29336         var mv uint
29337         hasLen := containerLen > 0
29338         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29339                 if esep {
29340                         dd.ReadMapElemKey()
29341                 }
29342                 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29343                 if esep {
29344                         dd.ReadMapElemValue()
29345                 }
29346                 if dd.TryDecodeAsNil() {
29347                         if v == nil {
29348                         } else if d.h.DeleteOnNilMapValue {
29349                                 delete(v, mk)
29350                         } else {
29351                                 v[mk] = 0
29352                         }
29353                         continue
29354                 }
29355                 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
29356                 if v != nil {
29357                         v[mk] = mv
29358                 }
29359         }
29360         dd.ReadMapEnd()
29361         d.depthDecr()
29362         return v, changed
29363 }
29364
29365 func (d *Decoder) fastpathDecMapIntUint8R(f *codecFnInfo, rv reflect.Value) {
29366         if rv.Kind() == reflect.Ptr {
29367                 vp := rv2i(rv).(*map[int]uint8)
29368                 v, changed := fastpathTV.DecMapIntUint8V(*vp, true, d)
29369                 if changed {
29370                         *vp = v
29371                 }
29372         } else {
29373                 fastpathTV.DecMapIntUint8V(rv2i(rv).(map[int]uint8), false, d)
29374         }
29375 }
29376 func (f fastpathT) DecMapIntUint8X(vp *map[int]uint8, d *Decoder) {
29377         v, changed := f.DecMapIntUint8V(*vp, true, d)
29378         if changed {
29379                 *vp = v
29380         }
29381 }
29382 func (_ fastpathT) DecMapIntUint8V(v map[int]uint8, canChange bool,
29383         d *Decoder) (_ map[int]uint8, changed bool) {
29384         dd, esep := d.d, d.hh.hasElemSeparators()
29385         containerLen := dd.ReadMapStart()
29386         if canChange && v == nil {
29387                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
29388                 v = make(map[int]uint8, xlen)
29389                 changed = true
29390         }
29391         if containerLen == 0 {
29392                 dd.ReadMapEnd()
29393                 return v, changed
29394         }
29395         d.depthIncr()
29396         var mk int
29397         var mv uint8
29398         hasLen := containerLen > 0
29399         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29400                 if esep {
29401                         dd.ReadMapElemKey()
29402                 }
29403                 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29404                 if esep {
29405                         dd.ReadMapElemValue()
29406                 }
29407                 if dd.TryDecodeAsNil() {
29408                         if v == nil {
29409                         } else if d.h.DeleteOnNilMapValue {
29410                                 delete(v, mk)
29411                         } else {
29412                                 v[mk] = 0
29413                         }
29414                         continue
29415                 }
29416                 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
29417                 if v != nil {
29418                         v[mk] = mv
29419                 }
29420         }
29421         dd.ReadMapEnd()
29422         d.depthDecr()
29423         return v, changed
29424 }
29425
29426 func (d *Decoder) fastpathDecMapIntUint16R(f *codecFnInfo, rv reflect.Value) {
29427         if rv.Kind() == reflect.Ptr {
29428                 vp := rv2i(rv).(*map[int]uint16)
29429                 v, changed := fastpathTV.DecMapIntUint16V(*vp, true, d)
29430                 if changed {
29431                         *vp = v
29432                 }
29433         } else {
29434                 fastpathTV.DecMapIntUint16V(rv2i(rv).(map[int]uint16), false, d)
29435         }
29436 }
29437 func (f fastpathT) DecMapIntUint16X(vp *map[int]uint16, d *Decoder) {
29438         v, changed := f.DecMapIntUint16V(*vp, true, d)
29439         if changed {
29440                 *vp = v
29441         }
29442 }
29443 func (_ fastpathT) DecMapIntUint16V(v map[int]uint16, canChange bool,
29444         d *Decoder) (_ map[int]uint16, changed bool) {
29445         dd, esep := d.d, d.hh.hasElemSeparators()
29446         containerLen := dd.ReadMapStart()
29447         if canChange && v == nil {
29448                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
29449                 v = make(map[int]uint16, xlen)
29450                 changed = true
29451         }
29452         if containerLen == 0 {
29453                 dd.ReadMapEnd()
29454                 return v, changed
29455         }
29456         d.depthIncr()
29457         var mk int
29458         var mv uint16
29459         hasLen := containerLen > 0
29460         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29461                 if esep {
29462                         dd.ReadMapElemKey()
29463                 }
29464                 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29465                 if esep {
29466                         dd.ReadMapElemValue()
29467                 }
29468                 if dd.TryDecodeAsNil() {
29469                         if v == nil {
29470                         } else if d.h.DeleteOnNilMapValue {
29471                                 delete(v, mk)
29472                         } else {
29473                                 v[mk] = 0
29474                         }
29475                         continue
29476                 }
29477                 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
29478                 if v != nil {
29479                         v[mk] = mv
29480                 }
29481         }
29482         dd.ReadMapEnd()
29483         d.depthDecr()
29484         return v, changed
29485 }
29486
29487 func (d *Decoder) fastpathDecMapIntUint32R(f *codecFnInfo, rv reflect.Value) {
29488         if rv.Kind() == reflect.Ptr {
29489                 vp := rv2i(rv).(*map[int]uint32)
29490                 v, changed := fastpathTV.DecMapIntUint32V(*vp, true, d)
29491                 if changed {
29492                         *vp = v
29493                 }
29494         } else {
29495                 fastpathTV.DecMapIntUint32V(rv2i(rv).(map[int]uint32), false, d)
29496         }
29497 }
29498 func (f fastpathT) DecMapIntUint32X(vp *map[int]uint32, d *Decoder) {
29499         v, changed := f.DecMapIntUint32V(*vp, true, d)
29500         if changed {
29501                 *vp = v
29502         }
29503 }
29504 func (_ fastpathT) DecMapIntUint32V(v map[int]uint32, canChange bool,
29505         d *Decoder) (_ map[int]uint32, changed bool) {
29506         dd, esep := d.d, d.hh.hasElemSeparators()
29507         containerLen := dd.ReadMapStart()
29508         if canChange && v == nil {
29509                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
29510                 v = make(map[int]uint32, xlen)
29511                 changed = true
29512         }
29513         if containerLen == 0 {
29514                 dd.ReadMapEnd()
29515                 return v, changed
29516         }
29517         d.depthIncr()
29518         var mk int
29519         var mv uint32
29520         hasLen := containerLen > 0
29521         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29522                 if esep {
29523                         dd.ReadMapElemKey()
29524                 }
29525                 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29526                 if esep {
29527                         dd.ReadMapElemValue()
29528                 }
29529                 if dd.TryDecodeAsNil() {
29530                         if v == nil {
29531                         } else if d.h.DeleteOnNilMapValue {
29532                                 delete(v, mk)
29533                         } else {
29534                                 v[mk] = 0
29535                         }
29536                         continue
29537                 }
29538                 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
29539                 if v != nil {
29540                         v[mk] = mv
29541                 }
29542         }
29543         dd.ReadMapEnd()
29544         d.depthDecr()
29545         return v, changed
29546 }
29547
29548 func (d *Decoder) fastpathDecMapIntUint64R(f *codecFnInfo, rv reflect.Value) {
29549         if rv.Kind() == reflect.Ptr {
29550                 vp := rv2i(rv).(*map[int]uint64)
29551                 v, changed := fastpathTV.DecMapIntUint64V(*vp, true, d)
29552                 if changed {
29553                         *vp = v
29554                 }
29555         } else {
29556                 fastpathTV.DecMapIntUint64V(rv2i(rv).(map[int]uint64), false, d)
29557         }
29558 }
29559 func (f fastpathT) DecMapIntUint64X(vp *map[int]uint64, d *Decoder) {
29560         v, changed := f.DecMapIntUint64V(*vp, true, d)
29561         if changed {
29562                 *vp = v
29563         }
29564 }
29565 func (_ fastpathT) DecMapIntUint64V(v map[int]uint64, canChange bool,
29566         d *Decoder) (_ map[int]uint64, changed bool) {
29567         dd, esep := d.d, d.hh.hasElemSeparators()
29568         containerLen := dd.ReadMapStart()
29569         if canChange && v == nil {
29570                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
29571                 v = make(map[int]uint64, xlen)
29572                 changed = true
29573         }
29574         if containerLen == 0 {
29575                 dd.ReadMapEnd()
29576                 return v, changed
29577         }
29578         d.depthIncr()
29579         var mk int
29580         var mv uint64
29581         hasLen := containerLen > 0
29582         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29583                 if esep {
29584                         dd.ReadMapElemKey()
29585                 }
29586                 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29587                 if esep {
29588                         dd.ReadMapElemValue()
29589                 }
29590                 if dd.TryDecodeAsNil() {
29591                         if v == nil {
29592                         } else if d.h.DeleteOnNilMapValue {
29593                                 delete(v, mk)
29594                         } else {
29595                                 v[mk] = 0
29596                         }
29597                         continue
29598                 }
29599                 mv = dd.DecodeUint64()
29600                 if v != nil {
29601                         v[mk] = mv
29602                 }
29603         }
29604         dd.ReadMapEnd()
29605         d.depthDecr()
29606         return v, changed
29607 }
29608
29609 func (d *Decoder) fastpathDecMapIntUintptrR(f *codecFnInfo, rv reflect.Value) {
29610         if rv.Kind() == reflect.Ptr {
29611                 vp := rv2i(rv).(*map[int]uintptr)
29612                 v, changed := fastpathTV.DecMapIntUintptrV(*vp, true, d)
29613                 if changed {
29614                         *vp = v
29615                 }
29616         } else {
29617                 fastpathTV.DecMapIntUintptrV(rv2i(rv).(map[int]uintptr), false, d)
29618         }
29619 }
29620 func (f fastpathT) DecMapIntUintptrX(vp *map[int]uintptr, d *Decoder) {
29621         v, changed := f.DecMapIntUintptrV(*vp, true, d)
29622         if changed {
29623                 *vp = v
29624         }
29625 }
29626 func (_ fastpathT) DecMapIntUintptrV(v map[int]uintptr, canChange bool,
29627         d *Decoder) (_ map[int]uintptr, changed bool) {
29628         dd, esep := d.d, d.hh.hasElemSeparators()
29629         containerLen := dd.ReadMapStart()
29630         if canChange && v == nil {
29631                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
29632                 v = make(map[int]uintptr, xlen)
29633                 changed = true
29634         }
29635         if containerLen == 0 {
29636                 dd.ReadMapEnd()
29637                 return v, changed
29638         }
29639         d.depthIncr()
29640         var mk int
29641         var mv uintptr
29642         hasLen := containerLen > 0
29643         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29644                 if esep {
29645                         dd.ReadMapElemKey()
29646                 }
29647                 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29648                 if esep {
29649                         dd.ReadMapElemValue()
29650                 }
29651                 if dd.TryDecodeAsNil() {
29652                         if v == nil {
29653                         } else if d.h.DeleteOnNilMapValue {
29654                                 delete(v, mk)
29655                         } else {
29656                                 v[mk] = 0
29657                         }
29658                         continue
29659                 }
29660                 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
29661                 if v != nil {
29662                         v[mk] = mv
29663                 }
29664         }
29665         dd.ReadMapEnd()
29666         d.depthDecr()
29667         return v, changed
29668 }
29669
29670 func (d *Decoder) fastpathDecMapIntIntR(f *codecFnInfo, rv reflect.Value) {
29671         if rv.Kind() == reflect.Ptr {
29672                 vp := rv2i(rv).(*map[int]int)
29673                 v, changed := fastpathTV.DecMapIntIntV(*vp, true, d)
29674                 if changed {
29675                         *vp = v
29676                 }
29677         } else {
29678                 fastpathTV.DecMapIntIntV(rv2i(rv).(map[int]int), false, d)
29679         }
29680 }
29681 func (f fastpathT) DecMapIntIntX(vp *map[int]int, d *Decoder) {
29682         v, changed := f.DecMapIntIntV(*vp, true, d)
29683         if changed {
29684                 *vp = v
29685         }
29686 }
29687 func (_ fastpathT) DecMapIntIntV(v map[int]int, canChange bool,
29688         d *Decoder) (_ map[int]int, changed bool) {
29689         dd, esep := d.d, d.hh.hasElemSeparators()
29690         containerLen := dd.ReadMapStart()
29691         if canChange && v == nil {
29692                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
29693                 v = make(map[int]int, xlen)
29694                 changed = true
29695         }
29696         if containerLen == 0 {
29697                 dd.ReadMapEnd()
29698                 return v, changed
29699         }
29700         d.depthIncr()
29701         var mk int
29702         var mv int
29703         hasLen := containerLen > 0
29704         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29705                 if esep {
29706                         dd.ReadMapElemKey()
29707                 }
29708                 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29709                 if esep {
29710                         dd.ReadMapElemValue()
29711                 }
29712                 if dd.TryDecodeAsNil() {
29713                         if v == nil {
29714                         } else if d.h.DeleteOnNilMapValue {
29715                                 delete(v, mk)
29716                         } else {
29717                                 v[mk] = 0
29718                         }
29719                         continue
29720                 }
29721                 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29722                 if v != nil {
29723                         v[mk] = mv
29724                 }
29725         }
29726         dd.ReadMapEnd()
29727         d.depthDecr()
29728         return v, changed
29729 }
29730
29731 func (d *Decoder) fastpathDecMapIntInt8R(f *codecFnInfo, rv reflect.Value) {
29732         if rv.Kind() == reflect.Ptr {
29733                 vp := rv2i(rv).(*map[int]int8)
29734                 v, changed := fastpathTV.DecMapIntInt8V(*vp, true, d)
29735                 if changed {
29736                         *vp = v
29737                 }
29738         } else {
29739                 fastpathTV.DecMapIntInt8V(rv2i(rv).(map[int]int8), false, d)
29740         }
29741 }
29742 func (f fastpathT) DecMapIntInt8X(vp *map[int]int8, d *Decoder) {
29743         v, changed := f.DecMapIntInt8V(*vp, true, d)
29744         if changed {
29745                 *vp = v
29746         }
29747 }
29748 func (_ fastpathT) DecMapIntInt8V(v map[int]int8, canChange bool,
29749         d *Decoder) (_ map[int]int8, changed bool) {
29750         dd, esep := d.d, d.hh.hasElemSeparators()
29751         containerLen := dd.ReadMapStart()
29752         if canChange && v == nil {
29753                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
29754                 v = make(map[int]int8, xlen)
29755                 changed = true
29756         }
29757         if containerLen == 0 {
29758                 dd.ReadMapEnd()
29759                 return v, changed
29760         }
29761         d.depthIncr()
29762         var mk int
29763         var mv int8
29764         hasLen := containerLen > 0
29765         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29766                 if esep {
29767                         dd.ReadMapElemKey()
29768                 }
29769                 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29770                 if esep {
29771                         dd.ReadMapElemValue()
29772                 }
29773                 if dd.TryDecodeAsNil() {
29774                         if v == nil {
29775                         } else if d.h.DeleteOnNilMapValue {
29776                                 delete(v, mk)
29777                         } else {
29778                                 v[mk] = 0
29779                         }
29780                         continue
29781                 }
29782                 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
29783                 if v != nil {
29784                         v[mk] = mv
29785                 }
29786         }
29787         dd.ReadMapEnd()
29788         d.depthDecr()
29789         return v, changed
29790 }
29791
29792 func (d *Decoder) fastpathDecMapIntInt16R(f *codecFnInfo, rv reflect.Value) {
29793         if rv.Kind() == reflect.Ptr {
29794                 vp := rv2i(rv).(*map[int]int16)
29795                 v, changed := fastpathTV.DecMapIntInt16V(*vp, true, d)
29796                 if changed {
29797                         *vp = v
29798                 }
29799         } else {
29800                 fastpathTV.DecMapIntInt16V(rv2i(rv).(map[int]int16), false, d)
29801         }
29802 }
29803 func (f fastpathT) DecMapIntInt16X(vp *map[int]int16, d *Decoder) {
29804         v, changed := f.DecMapIntInt16V(*vp, true, d)
29805         if changed {
29806                 *vp = v
29807         }
29808 }
29809 func (_ fastpathT) DecMapIntInt16V(v map[int]int16, canChange bool,
29810         d *Decoder) (_ map[int]int16, changed bool) {
29811         dd, esep := d.d, d.hh.hasElemSeparators()
29812         containerLen := dd.ReadMapStart()
29813         if canChange && v == nil {
29814                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
29815                 v = make(map[int]int16, xlen)
29816                 changed = true
29817         }
29818         if containerLen == 0 {
29819                 dd.ReadMapEnd()
29820                 return v, changed
29821         }
29822         d.depthIncr()
29823         var mk int
29824         var mv int16
29825         hasLen := containerLen > 0
29826         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29827                 if esep {
29828                         dd.ReadMapElemKey()
29829                 }
29830                 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29831                 if esep {
29832                         dd.ReadMapElemValue()
29833                 }
29834                 if dd.TryDecodeAsNil() {
29835                         if v == nil {
29836                         } else if d.h.DeleteOnNilMapValue {
29837                                 delete(v, mk)
29838                         } else {
29839                                 v[mk] = 0
29840                         }
29841                         continue
29842                 }
29843                 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
29844                 if v != nil {
29845                         v[mk] = mv
29846                 }
29847         }
29848         dd.ReadMapEnd()
29849         d.depthDecr()
29850         return v, changed
29851 }
29852
29853 func (d *Decoder) fastpathDecMapIntInt32R(f *codecFnInfo, rv reflect.Value) {
29854         if rv.Kind() == reflect.Ptr {
29855                 vp := rv2i(rv).(*map[int]int32)
29856                 v, changed := fastpathTV.DecMapIntInt32V(*vp, true, d)
29857                 if changed {
29858                         *vp = v
29859                 }
29860         } else {
29861                 fastpathTV.DecMapIntInt32V(rv2i(rv).(map[int]int32), false, d)
29862         }
29863 }
29864 func (f fastpathT) DecMapIntInt32X(vp *map[int]int32, d *Decoder) {
29865         v, changed := f.DecMapIntInt32V(*vp, true, d)
29866         if changed {
29867                 *vp = v
29868         }
29869 }
29870 func (_ fastpathT) DecMapIntInt32V(v map[int]int32, canChange bool,
29871         d *Decoder) (_ map[int]int32, changed bool) {
29872         dd, esep := d.d, d.hh.hasElemSeparators()
29873         containerLen := dd.ReadMapStart()
29874         if canChange && v == nil {
29875                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
29876                 v = make(map[int]int32, xlen)
29877                 changed = true
29878         }
29879         if containerLen == 0 {
29880                 dd.ReadMapEnd()
29881                 return v, changed
29882         }
29883         d.depthIncr()
29884         var mk int
29885         var mv int32
29886         hasLen := containerLen > 0
29887         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29888                 if esep {
29889                         dd.ReadMapElemKey()
29890                 }
29891                 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29892                 if esep {
29893                         dd.ReadMapElemValue()
29894                 }
29895                 if dd.TryDecodeAsNil() {
29896                         if v == nil {
29897                         } else if d.h.DeleteOnNilMapValue {
29898                                 delete(v, mk)
29899                         } else {
29900                                 v[mk] = 0
29901                         }
29902                         continue
29903                 }
29904                 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
29905                 if v != nil {
29906                         v[mk] = mv
29907                 }
29908         }
29909         dd.ReadMapEnd()
29910         d.depthDecr()
29911         return v, changed
29912 }
29913
29914 func (d *Decoder) fastpathDecMapIntInt64R(f *codecFnInfo, rv reflect.Value) {
29915         if rv.Kind() == reflect.Ptr {
29916                 vp := rv2i(rv).(*map[int]int64)
29917                 v, changed := fastpathTV.DecMapIntInt64V(*vp, true, d)
29918                 if changed {
29919                         *vp = v
29920                 }
29921         } else {
29922                 fastpathTV.DecMapIntInt64V(rv2i(rv).(map[int]int64), false, d)
29923         }
29924 }
29925 func (f fastpathT) DecMapIntInt64X(vp *map[int]int64, d *Decoder) {
29926         v, changed := f.DecMapIntInt64V(*vp, true, d)
29927         if changed {
29928                 *vp = v
29929         }
29930 }
29931 func (_ fastpathT) DecMapIntInt64V(v map[int]int64, canChange bool,
29932         d *Decoder) (_ map[int]int64, changed bool) {
29933         dd, esep := d.d, d.hh.hasElemSeparators()
29934         containerLen := dd.ReadMapStart()
29935         if canChange && v == nil {
29936                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
29937                 v = make(map[int]int64, xlen)
29938                 changed = true
29939         }
29940         if containerLen == 0 {
29941                 dd.ReadMapEnd()
29942                 return v, changed
29943         }
29944         d.depthIncr()
29945         var mk int
29946         var mv int64
29947         hasLen := containerLen > 0
29948         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29949                 if esep {
29950                         dd.ReadMapElemKey()
29951                 }
29952                 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29953                 if esep {
29954                         dd.ReadMapElemValue()
29955                 }
29956                 if dd.TryDecodeAsNil() {
29957                         if v == nil {
29958                         } else if d.h.DeleteOnNilMapValue {
29959                                 delete(v, mk)
29960                         } else {
29961                                 v[mk] = 0
29962                         }
29963                         continue
29964                 }
29965                 mv = dd.DecodeInt64()
29966                 if v != nil {
29967                         v[mk] = mv
29968                 }
29969         }
29970         dd.ReadMapEnd()
29971         d.depthDecr()
29972         return v, changed
29973 }
29974
29975 func (d *Decoder) fastpathDecMapIntFloat32R(f *codecFnInfo, rv reflect.Value) {
29976         if rv.Kind() == reflect.Ptr {
29977                 vp := rv2i(rv).(*map[int]float32)
29978                 v, changed := fastpathTV.DecMapIntFloat32V(*vp, true, d)
29979                 if changed {
29980                         *vp = v
29981                 }
29982         } else {
29983                 fastpathTV.DecMapIntFloat32V(rv2i(rv).(map[int]float32), false, d)
29984         }
29985 }
29986 func (f fastpathT) DecMapIntFloat32X(vp *map[int]float32, d *Decoder) {
29987         v, changed := f.DecMapIntFloat32V(*vp, true, d)
29988         if changed {
29989                 *vp = v
29990         }
29991 }
29992 func (_ fastpathT) DecMapIntFloat32V(v map[int]float32, canChange bool,
29993         d *Decoder) (_ map[int]float32, changed bool) {
29994         dd, esep := d.d, d.hh.hasElemSeparators()
29995         containerLen := dd.ReadMapStart()
29996         if canChange && v == nil {
29997                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
29998                 v = make(map[int]float32, xlen)
29999                 changed = true
30000         }
30001         if containerLen == 0 {
30002                 dd.ReadMapEnd()
30003                 return v, changed
30004         }
30005         d.depthIncr()
30006         var mk int
30007         var mv float32
30008         hasLen := containerLen > 0
30009         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30010                 if esep {
30011                         dd.ReadMapElemKey()
30012                 }
30013                 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
30014                 if esep {
30015                         dd.ReadMapElemValue()
30016                 }
30017                 if dd.TryDecodeAsNil() {
30018                         if v == nil {
30019                         } else if d.h.DeleteOnNilMapValue {
30020                                 delete(v, mk)
30021                         } else {
30022                                 v[mk] = 0
30023                         }
30024                         continue
30025                 }
30026                 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
30027                 if v != nil {
30028                         v[mk] = mv
30029                 }
30030         }
30031         dd.ReadMapEnd()
30032         d.depthDecr()
30033         return v, changed
30034 }
30035
30036 func (d *Decoder) fastpathDecMapIntFloat64R(f *codecFnInfo, rv reflect.Value) {
30037         if rv.Kind() == reflect.Ptr {
30038                 vp := rv2i(rv).(*map[int]float64)
30039                 v, changed := fastpathTV.DecMapIntFloat64V(*vp, true, d)
30040                 if changed {
30041                         *vp = v
30042                 }
30043         } else {
30044                 fastpathTV.DecMapIntFloat64V(rv2i(rv).(map[int]float64), false, d)
30045         }
30046 }
30047 func (f fastpathT) DecMapIntFloat64X(vp *map[int]float64, d *Decoder) {
30048         v, changed := f.DecMapIntFloat64V(*vp, true, d)
30049         if changed {
30050                 *vp = v
30051         }
30052 }
30053 func (_ fastpathT) DecMapIntFloat64V(v map[int]float64, canChange bool,
30054         d *Decoder) (_ map[int]float64, changed bool) {
30055         dd, esep := d.d, d.hh.hasElemSeparators()
30056         containerLen := dd.ReadMapStart()
30057         if canChange && v == nil {
30058                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
30059                 v = make(map[int]float64, xlen)
30060                 changed = true
30061         }
30062         if containerLen == 0 {
30063                 dd.ReadMapEnd()
30064                 return v, changed
30065         }
30066         d.depthIncr()
30067         var mk int
30068         var mv float64
30069         hasLen := containerLen > 0
30070         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30071                 if esep {
30072                         dd.ReadMapElemKey()
30073                 }
30074                 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
30075                 if esep {
30076                         dd.ReadMapElemValue()
30077                 }
30078                 if dd.TryDecodeAsNil() {
30079                         if v == nil {
30080                         } else if d.h.DeleteOnNilMapValue {
30081                                 delete(v, mk)
30082                         } else {
30083                                 v[mk] = 0
30084                         }
30085                         continue
30086                 }
30087                 mv = dd.DecodeFloat64()
30088                 if v != nil {
30089                         v[mk] = mv
30090                 }
30091         }
30092         dd.ReadMapEnd()
30093         d.depthDecr()
30094         return v, changed
30095 }
30096
30097 func (d *Decoder) fastpathDecMapIntBoolR(f *codecFnInfo, rv reflect.Value) {
30098         if rv.Kind() == reflect.Ptr {
30099                 vp := rv2i(rv).(*map[int]bool)
30100                 v, changed := fastpathTV.DecMapIntBoolV(*vp, true, d)
30101                 if changed {
30102                         *vp = v
30103                 }
30104         } else {
30105                 fastpathTV.DecMapIntBoolV(rv2i(rv).(map[int]bool), false, d)
30106         }
30107 }
30108 func (f fastpathT) DecMapIntBoolX(vp *map[int]bool, d *Decoder) {
30109         v, changed := f.DecMapIntBoolV(*vp, true, d)
30110         if changed {
30111                 *vp = v
30112         }
30113 }
30114 func (_ fastpathT) DecMapIntBoolV(v map[int]bool, canChange bool,
30115         d *Decoder) (_ map[int]bool, changed bool) {
30116         dd, esep := d.d, d.hh.hasElemSeparators()
30117         containerLen := dd.ReadMapStart()
30118         if canChange && v == nil {
30119                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
30120                 v = make(map[int]bool, xlen)
30121                 changed = true
30122         }
30123         if containerLen == 0 {
30124                 dd.ReadMapEnd()
30125                 return v, changed
30126         }
30127         d.depthIncr()
30128         var mk int
30129         var mv bool
30130         hasLen := containerLen > 0
30131         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30132                 if esep {
30133                         dd.ReadMapElemKey()
30134                 }
30135                 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
30136                 if esep {
30137                         dd.ReadMapElemValue()
30138                 }
30139                 if dd.TryDecodeAsNil() {
30140                         if v == nil {
30141                         } else if d.h.DeleteOnNilMapValue {
30142                                 delete(v, mk)
30143                         } else {
30144                                 v[mk] = false
30145                         }
30146                         continue
30147                 }
30148                 mv = dd.DecodeBool()
30149                 if v != nil {
30150                         v[mk] = mv
30151                 }
30152         }
30153         dd.ReadMapEnd()
30154         d.depthDecr()
30155         return v, changed
30156 }
30157
30158 func (d *Decoder) fastpathDecMapInt8IntfR(f *codecFnInfo, rv reflect.Value) {
30159         if rv.Kind() == reflect.Ptr {
30160                 vp := rv2i(rv).(*map[int8]interface{})
30161                 v, changed := fastpathTV.DecMapInt8IntfV(*vp, true, d)
30162                 if changed {
30163                         *vp = v
30164                 }
30165         } else {
30166                 fastpathTV.DecMapInt8IntfV(rv2i(rv).(map[int8]interface{}), false, d)
30167         }
30168 }
30169 func (f fastpathT) DecMapInt8IntfX(vp *map[int8]interface{}, d *Decoder) {
30170         v, changed := f.DecMapInt8IntfV(*vp, true, d)
30171         if changed {
30172                 *vp = v
30173         }
30174 }
30175 func (_ fastpathT) DecMapInt8IntfV(v map[int8]interface{}, canChange bool,
30176         d *Decoder) (_ map[int8]interface{}, changed bool) {
30177         dd, esep := d.d, d.hh.hasElemSeparators()
30178         containerLen := dd.ReadMapStart()
30179         if canChange && v == nil {
30180                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
30181                 v = make(map[int8]interface{}, xlen)
30182                 changed = true
30183         }
30184         if containerLen == 0 {
30185                 dd.ReadMapEnd()
30186                 return v, changed
30187         }
30188         d.depthIncr()
30189         mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
30190         var mk int8
30191         var mv interface{}
30192         hasLen := containerLen > 0
30193         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30194                 if esep {
30195                         dd.ReadMapElemKey()
30196                 }
30197                 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30198                 if esep {
30199                         dd.ReadMapElemValue()
30200                 }
30201                 if dd.TryDecodeAsNil() {
30202                         if v == nil {
30203                         } else if d.h.DeleteOnNilMapValue {
30204                                 delete(v, mk)
30205                         } else {
30206                                 v[mk] = nil
30207                         }
30208                         continue
30209                 }
30210                 if mapGet {
30211                         mv = v[mk]
30212                 } else {
30213                         mv = nil
30214                 }
30215                 d.decode(&mv)
30216                 if v != nil {
30217                         v[mk] = mv
30218                 }
30219         }
30220         dd.ReadMapEnd()
30221         d.depthDecr()
30222         return v, changed
30223 }
30224
30225 func (d *Decoder) fastpathDecMapInt8StringR(f *codecFnInfo, rv reflect.Value) {
30226         if rv.Kind() == reflect.Ptr {
30227                 vp := rv2i(rv).(*map[int8]string)
30228                 v, changed := fastpathTV.DecMapInt8StringV(*vp, true, d)
30229                 if changed {
30230                         *vp = v
30231                 }
30232         } else {
30233                 fastpathTV.DecMapInt8StringV(rv2i(rv).(map[int8]string), false, d)
30234         }
30235 }
30236 func (f fastpathT) DecMapInt8StringX(vp *map[int8]string, d *Decoder) {
30237         v, changed := f.DecMapInt8StringV(*vp, true, d)
30238         if changed {
30239                 *vp = v
30240         }
30241 }
30242 func (_ fastpathT) DecMapInt8StringV(v map[int8]string, canChange bool,
30243         d *Decoder) (_ map[int8]string, changed bool) {
30244         dd, esep := d.d, d.hh.hasElemSeparators()
30245         containerLen := dd.ReadMapStart()
30246         if canChange && v == nil {
30247                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
30248                 v = make(map[int8]string, xlen)
30249                 changed = true
30250         }
30251         if containerLen == 0 {
30252                 dd.ReadMapEnd()
30253                 return v, changed
30254         }
30255         d.depthIncr()
30256         var mk int8
30257         var mv string
30258         hasLen := containerLen > 0
30259         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30260                 if esep {
30261                         dd.ReadMapElemKey()
30262                 }
30263                 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30264                 if esep {
30265                         dd.ReadMapElemValue()
30266                 }
30267                 if dd.TryDecodeAsNil() {
30268                         if v == nil {
30269                         } else if d.h.DeleteOnNilMapValue {
30270                                 delete(v, mk)
30271                         } else {
30272                                 v[mk] = ""
30273                         }
30274                         continue
30275                 }
30276                 mv = dd.DecodeString()
30277                 if v != nil {
30278                         v[mk] = mv
30279                 }
30280         }
30281         dd.ReadMapEnd()
30282         d.depthDecr()
30283         return v, changed
30284 }
30285
30286 func (d *Decoder) fastpathDecMapInt8UintR(f *codecFnInfo, rv reflect.Value) {
30287         if rv.Kind() == reflect.Ptr {
30288                 vp := rv2i(rv).(*map[int8]uint)
30289                 v, changed := fastpathTV.DecMapInt8UintV(*vp, true, d)
30290                 if changed {
30291                         *vp = v
30292                 }
30293         } else {
30294                 fastpathTV.DecMapInt8UintV(rv2i(rv).(map[int8]uint), false, d)
30295         }
30296 }
30297 func (f fastpathT) DecMapInt8UintX(vp *map[int8]uint, d *Decoder) {
30298         v, changed := f.DecMapInt8UintV(*vp, true, d)
30299         if changed {
30300                 *vp = v
30301         }
30302 }
30303 func (_ fastpathT) DecMapInt8UintV(v map[int8]uint, canChange bool,
30304         d *Decoder) (_ map[int8]uint, changed bool) {
30305         dd, esep := d.d, d.hh.hasElemSeparators()
30306         containerLen := dd.ReadMapStart()
30307         if canChange && v == nil {
30308                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
30309                 v = make(map[int8]uint, xlen)
30310                 changed = true
30311         }
30312         if containerLen == 0 {
30313                 dd.ReadMapEnd()
30314                 return v, changed
30315         }
30316         d.depthIncr()
30317         var mk int8
30318         var mv uint
30319         hasLen := containerLen > 0
30320         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30321                 if esep {
30322                         dd.ReadMapElemKey()
30323                 }
30324                 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30325                 if esep {
30326                         dd.ReadMapElemValue()
30327                 }
30328                 if dd.TryDecodeAsNil() {
30329                         if v == nil {
30330                         } else if d.h.DeleteOnNilMapValue {
30331                                 delete(v, mk)
30332                         } else {
30333                                 v[mk] = 0
30334                         }
30335                         continue
30336                 }
30337                 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
30338                 if v != nil {
30339                         v[mk] = mv
30340                 }
30341         }
30342         dd.ReadMapEnd()
30343         d.depthDecr()
30344         return v, changed
30345 }
30346
30347 func (d *Decoder) fastpathDecMapInt8Uint8R(f *codecFnInfo, rv reflect.Value) {
30348         if rv.Kind() == reflect.Ptr {
30349                 vp := rv2i(rv).(*map[int8]uint8)
30350                 v, changed := fastpathTV.DecMapInt8Uint8V(*vp, true, d)
30351                 if changed {
30352                         *vp = v
30353                 }
30354         } else {
30355                 fastpathTV.DecMapInt8Uint8V(rv2i(rv).(map[int8]uint8), false, d)
30356         }
30357 }
30358 func (f fastpathT) DecMapInt8Uint8X(vp *map[int8]uint8, d *Decoder) {
30359         v, changed := f.DecMapInt8Uint8V(*vp, true, d)
30360         if changed {
30361                 *vp = v
30362         }
30363 }
30364 func (_ fastpathT) DecMapInt8Uint8V(v map[int8]uint8, canChange bool,
30365         d *Decoder) (_ map[int8]uint8, changed bool) {
30366         dd, esep := d.d, d.hh.hasElemSeparators()
30367         containerLen := dd.ReadMapStart()
30368         if canChange && v == nil {
30369                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
30370                 v = make(map[int8]uint8, xlen)
30371                 changed = true
30372         }
30373         if containerLen == 0 {
30374                 dd.ReadMapEnd()
30375                 return v, changed
30376         }
30377         d.depthIncr()
30378         var mk int8
30379         var mv uint8
30380         hasLen := containerLen > 0
30381         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30382                 if esep {
30383                         dd.ReadMapElemKey()
30384                 }
30385                 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30386                 if esep {
30387                         dd.ReadMapElemValue()
30388                 }
30389                 if dd.TryDecodeAsNil() {
30390                         if v == nil {
30391                         } else if d.h.DeleteOnNilMapValue {
30392                                 delete(v, mk)
30393                         } else {
30394                                 v[mk] = 0
30395                         }
30396                         continue
30397                 }
30398                 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
30399                 if v != nil {
30400                         v[mk] = mv
30401                 }
30402         }
30403         dd.ReadMapEnd()
30404         d.depthDecr()
30405         return v, changed
30406 }
30407
30408 func (d *Decoder) fastpathDecMapInt8Uint16R(f *codecFnInfo, rv reflect.Value) {
30409         if rv.Kind() == reflect.Ptr {
30410                 vp := rv2i(rv).(*map[int8]uint16)
30411                 v, changed := fastpathTV.DecMapInt8Uint16V(*vp, true, d)
30412                 if changed {
30413                         *vp = v
30414                 }
30415         } else {
30416                 fastpathTV.DecMapInt8Uint16V(rv2i(rv).(map[int8]uint16), false, d)
30417         }
30418 }
30419 func (f fastpathT) DecMapInt8Uint16X(vp *map[int8]uint16, d *Decoder) {
30420         v, changed := f.DecMapInt8Uint16V(*vp, true, d)
30421         if changed {
30422                 *vp = v
30423         }
30424 }
30425 func (_ fastpathT) DecMapInt8Uint16V(v map[int8]uint16, canChange bool,
30426         d *Decoder) (_ map[int8]uint16, changed bool) {
30427         dd, esep := d.d, d.hh.hasElemSeparators()
30428         containerLen := dd.ReadMapStart()
30429         if canChange && v == nil {
30430                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
30431                 v = make(map[int8]uint16, xlen)
30432                 changed = true
30433         }
30434         if containerLen == 0 {
30435                 dd.ReadMapEnd()
30436                 return v, changed
30437         }
30438         d.depthIncr()
30439         var mk int8
30440         var mv uint16
30441         hasLen := containerLen > 0
30442         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30443                 if esep {
30444                         dd.ReadMapElemKey()
30445                 }
30446                 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30447                 if esep {
30448                         dd.ReadMapElemValue()
30449                 }
30450                 if dd.TryDecodeAsNil() {
30451                         if v == nil {
30452                         } else if d.h.DeleteOnNilMapValue {
30453                                 delete(v, mk)
30454                         } else {
30455                                 v[mk] = 0
30456                         }
30457                         continue
30458                 }
30459                 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
30460                 if v != nil {
30461                         v[mk] = mv
30462                 }
30463         }
30464         dd.ReadMapEnd()
30465         d.depthDecr()
30466         return v, changed
30467 }
30468
30469 func (d *Decoder) fastpathDecMapInt8Uint32R(f *codecFnInfo, rv reflect.Value) {
30470         if rv.Kind() == reflect.Ptr {
30471                 vp := rv2i(rv).(*map[int8]uint32)
30472                 v, changed := fastpathTV.DecMapInt8Uint32V(*vp, true, d)
30473                 if changed {
30474                         *vp = v
30475                 }
30476         } else {
30477                 fastpathTV.DecMapInt8Uint32V(rv2i(rv).(map[int8]uint32), false, d)
30478         }
30479 }
30480 func (f fastpathT) DecMapInt8Uint32X(vp *map[int8]uint32, d *Decoder) {
30481         v, changed := f.DecMapInt8Uint32V(*vp, true, d)
30482         if changed {
30483                 *vp = v
30484         }
30485 }
30486 func (_ fastpathT) DecMapInt8Uint32V(v map[int8]uint32, canChange bool,
30487         d *Decoder) (_ map[int8]uint32, changed bool) {
30488         dd, esep := d.d, d.hh.hasElemSeparators()
30489         containerLen := dd.ReadMapStart()
30490         if canChange && v == nil {
30491                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
30492                 v = make(map[int8]uint32, xlen)
30493                 changed = true
30494         }
30495         if containerLen == 0 {
30496                 dd.ReadMapEnd()
30497                 return v, changed
30498         }
30499         d.depthIncr()
30500         var mk int8
30501         var mv uint32
30502         hasLen := containerLen > 0
30503         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30504                 if esep {
30505                         dd.ReadMapElemKey()
30506                 }
30507                 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30508                 if esep {
30509                         dd.ReadMapElemValue()
30510                 }
30511                 if dd.TryDecodeAsNil() {
30512                         if v == nil {
30513                         } else if d.h.DeleteOnNilMapValue {
30514                                 delete(v, mk)
30515                         } else {
30516                                 v[mk] = 0
30517                         }
30518                         continue
30519                 }
30520                 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
30521                 if v != nil {
30522                         v[mk] = mv
30523                 }
30524         }
30525         dd.ReadMapEnd()
30526         d.depthDecr()
30527         return v, changed
30528 }
30529
30530 func (d *Decoder) fastpathDecMapInt8Uint64R(f *codecFnInfo, rv reflect.Value) {
30531         if rv.Kind() == reflect.Ptr {
30532                 vp := rv2i(rv).(*map[int8]uint64)
30533                 v, changed := fastpathTV.DecMapInt8Uint64V(*vp, true, d)
30534                 if changed {
30535                         *vp = v
30536                 }
30537         } else {
30538                 fastpathTV.DecMapInt8Uint64V(rv2i(rv).(map[int8]uint64), false, d)
30539         }
30540 }
30541 func (f fastpathT) DecMapInt8Uint64X(vp *map[int8]uint64, d *Decoder) {
30542         v, changed := f.DecMapInt8Uint64V(*vp, true, d)
30543         if changed {
30544                 *vp = v
30545         }
30546 }
30547 func (_ fastpathT) DecMapInt8Uint64V(v map[int8]uint64, canChange bool,
30548         d *Decoder) (_ map[int8]uint64, changed bool) {
30549         dd, esep := d.d, d.hh.hasElemSeparators()
30550         containerLen := dd.ReadMapStart()
30551         if canChange && v == nil {
30552                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
30553                 v = make(map[int8]uint64, xlen)
30554                 changed = true
30555         }
30556         if containerLen == 0 {
30557                 dd.ReadMapEnd()
30558                 return v, changed
30559         }
30560         d.depthIncr()
30561         var mk int8
30562         var mv uint64
30563         hasLen := containerLen > 0
30564         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30565                 if esep {
30566                         dd.ReadMapElemKey()
30567                 }
30568                 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30569                 if esep {
30570                         dd.ReadMapElemValue()
30571                 }
30572                 if dd.TryDecodeAsNil() {
30573                         if v == nil {
30574                         } else if d.h.DeleteOnNilMapValue {
30575                                 delete(v, mk)
30576                         } else {
30577                                 v[mk] = 0
30578                         }
30579                         continue
30580                 }
30581                 mv = dd.DecodeUint64()
30582                 if v != nil {
30583                         v[mk] = mv
30584                 }
30585         }
30586         dd.ReadMapEnd()
30587         d.depthDecr()
30588         return v, changed
30589 }
30590
30591 func (d *Decoder) fastpathDecMapInt8UintptrR(f *codecFnInfo, rv reflect.Value) {
30592         if rv.Kind() == reflect.Ptr {
30593                 vp := rv2i(rv).(*map[int8]uintptr)
30594                 v, changed := fastpathTV.DecMapInt8UintptrV(*vp, true, d)
30595                 if changed {
30596                         *vp = v
30597                 }
30598         } else {
30599                 fastpathTV.DecMapInt8UintptrV(rv2i(rv).(map[int8]uintptr), false, d)
30600         }
30601 }
30602 func (f fastpathT) DecMapInt8UintptrX(vp *map[int8]uintptr, d *Decoder) {
30603         v, changed := f.DecMapInt8UintptrV(*vp, true, d)
30604         if changed {
30605                 *vp = v
30606         }
30607 }
30608 func (_ fastpathT) DecMapInt8UintptrV(v map[int8]uintptr, canChange bool,
30609         d *Decoder) (_ map[int8]uintptr, changed bool) {
30610         dd, esep := d.d, d.hh.hasElemSeparators()
30611         containerLen := dd.ReadMapStart()
30612         if canChange && v == nil {
30613                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
30614                 v = make(map[int8]uintptr, xlen)
30615                 changed = true
30616         }
30617         if containerLen == 0 {
30618                 dd.ReadMapEnd()
30619                 return v, changed
30620         }
30621         d.depthIncr()
30622         var mk int8
30623         var mv uintptr
30624         hasLen := containerLen > 0
30625         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30626                 if esep {
30627                         dd.ReadMapElemKey()
30628                 }
30629                 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30630                 if esep {
30631                         dd.ReadMapElemValue()
30632                 }
30633                 if dd.TryDecodeAsNil() {
30634                         if v == nil {
30635                         } else if d.h.DeleteOnNilMapValue {
30636                                 delete(v, mk)
30637                         } else {
30638                                 v[mk] = 0
30639                         }
30640                         continue
30641                 }
30642                 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
30643                 if v != nil {
30644                         v[mk] = mv
30645                 }
30646         }
30647         dd.ReadMapEnd()
30648         d.depthDecr()
30649         return v, changed
30650 }
30651
30652 func (d *Decoder) fastpathDecMapInt8IntR(f *codecFnInfo, rv reflect.Value) {
30653         if rv.Kind() == reflect.Ptr {
30654                 vp := rv2i(rv).(*map[int8]int)
30655                 v, changed := fastpathTV.DecMapInt8IntV(*vp, true, d)
30656                 if changed {
30657                         *vp = v
30658                 }
30659         } else {
30660                 fastpathTV.DecMapInt8IntV(rv2i(rv).(map[int8]int), false, d)
30661         }
30662 }
30663 func (f fastpathT) DecMapInt8IntX(vp *map[int8]int, d *Decoder) {
30664         v, changed := f.DecMapInt8IntV(*vp, true, d)
30665         if changed {
30666                 *vp = v
30667         }
30668 }
30669 func (_ fastpathT) DecMapInt8IntV(v map[int8]int, canChange bool,
30670         d *Decoder) (_ map[int8]int, changed bool) {
30671         dd, esep := d.d, d.hh.hasElemSeparators()
30672         containerLen := dd.ReadMapStart()
30673         if canChange && v == nil {
30674                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
30675                 v = make(map[int8]int, xlen)
30676                 changed = true
30677         }
30678         if containerLen == 0 {
30679                 dd.ReadMapEnd()
30680                 return v, changed
30681         }
30682         d.depthIncr()
30683         var mk int8
30684         var mv int
30685         hasLen := containerLen > 0
30686         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30687                 if esep {
30688                         dd.ReadMapElemKey()
30689                 }
30690                 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30691                 if esep {
30692                         dd.ReadMapElemValue()
30693                 }
30694                 if dd.TryDecodeAsNil() {
30695                         if v == nil {
30696                         } else if d.h.DeleteOnNilMapValue {
30697                                 delete(v, mk)
30698                         } else {
30699                                 v[mk] = 0
30700                         }
30701                         continue
30702                 }
30703                 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
30704                 if v != nil {
30705                         v[mk] = mv
30706                 }
30707         }
30708         dd.ReadMapEnd()
30709         d.depthDecr()
30710         return v, changed
30711 }
30712
30713 func (d *Decoder) fastpathDecMapInt8Int8R(f *codecFnInfo, rv reflect.Value) {
30714         if rv.Kind() == reflect.Ptr {
30715                 vp := rv2i(rv).(*map[int8]int8)
30716                 v, changed := fastpathTV.DecMapInt8Int8V(*vp, true, d)
30717                 if changed {
30718                         *vp = v
30719                 }
30720         } else {
30721                 fastpathTV.DecMapInt8Int8V(rv2i(rv).(map[int8]int8), false, d)
30722         }
30723 }
30724 func (f fastpathT) DecMapInt8Int8X(vp *map[int8]int8, d *Decoder) {
30725         v, changed := f.DecMapInt8Int8V(*vp, true, d)
30726         if changed {
30727                 *vp = v
30728         }
30729 }
30730 func (_ fastpathT) DecMapInt8Int8V(v map[int8]int8, canChange bool,
30731         d *Decoder) (_ map[int8]int8, changed bool) {
30732         dd, esep := d.d, d.hh.hasElemSeparators()
30733         containerLen := dd.ReadMapStart()
30734         if canChange && v == nil {
30735                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
30736                 v = make(map[int8]int8, xlen)
30737                 changed = true
30738         }
30739         if containerLen == 0 {
30740                 dd.ReadMapEnd()
30741                 return v, changed
30742         }
30743         d.depthIncr()
30744         var mk int8
30745         var mv int8
30746         hasLen := containerLen > 0
30747         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30748                 if esep {
30749                         dd.ReadMapElemKey()
30750                 }
30751                 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30752                 if esep {
30753                         dd.ReadMapElemValue()
30754                 }
30755                 if dd.TryDecodeAsNil() {
30756                         if v == nil {
30757                         } else if d.h.DeleteOnNilMapValue {
30758                                 delete(v, mk)
30759                         } else {
30760                                 v[mk] = 0
30761                         }
30762                         continue
30763                 }
30764                 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30765                 if v != nil {
30766                         v[mk] = mv
30767                 }
30768         }
30769         dd.ReadMapEnd()
30770         d.depthDecr()
30771         return v, changed
30772 }
30773
30774 func (d *Decoder) fastpathDecMapInt8Int16R(f *codecFnInfo, rv reflect.Value) {
30775         if rv.Kind() == reflect.Ptr {
30776                 vp := rv2i(rv).(*map[int8]int16)
30777                 v, changed := fastpathTV.DecMapInt8Int16V(*vp, true, d)
30778                 if changed {
30779                         *vp = v
30780                 }
30781         } else {
30782                 fastpathTV.DecMapInt8Int16V(rv2i(rv).(map[int8]int16), false, d)
30783         }
30784 }
30785 func (f fastpathT) DecMapInt8Int16X(vp *map[int8]int16, d *Decoder) {
30786         v, changed := f.DecMapInt8Int16V(*vp, true, d)
30787         if changed {
30788                 *vp = v
30789         }
30790 }
30791 func (_ fastpathT) DecMapInt8Int16V(v map[int8]int16, canChange bool,
30792         d *Decoder) (_ map[int8]int16, changed bool) {
30793         dd, esep := d.d, d.hh.hasElemSeparators()
30794         containerLen := dd.ReadMapStart()
30795         if canChange && v == nil {
30796                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
30797                 v = make(map[int8]int16, xlen)
30798                 changed = true
30799         }
30800         if containerLen == 0 {
30801                 dd.ReadMapEnd()
30802                 return v, changed
30803         }
30804         d.depthIncr()
30805         var mk int8
30806         var mv int16
30807         hasLen := containerLen > 0
30808         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30809                 if esep {
30810                         dd.ReadMapElemKey()
30811                 }
30812                 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30813                 if esep {
30814                         dd.ReadMapElemValue()
30815                 }
30816                 if dd.TryDecodeAsNil() {
30817                         if v == nil {
30818                         } else if d.h.DeleteOnNilMapValue {
30819                                 delete(v, mk)
30820                         } else {
30821                                 v[mk] = 0
30822                         }
30823                         continue
30824                 }
30825                 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
30826                 if v != nil {
30827                         v[mk] = mv
30828                 }
30829         }
30830         dd.ReadMapEnd()
30831         d.depthDecr()
30832         return v, changed
30833 }
30834
30835 func (d *Decoder) fastpathDecMapInt8Int32R(f *codecFnInfo, rv reflect.Value) {
30836         if rv.Kind() == reflect.Ptr {
30837                 vp := rv2i(rv).(*map[int8]int32)
30838                 v, changed := fastpathTV.DecMapInt8Int32V(*vp, true, d)
30839                 if changed {
30840                         *vp = v
30841                 }
30842         } else {
30843                 fastpathTV.DecMapInt8Int32V(rv2i(rv).(map[int8]int32), false, d)
30844         }
30845 }
30846 func (f fastpathT) DecMapInt8Int32X(vp *map[int8]int32, d *Decoder) {
30847         v, changed := f.DecMapInt8Int32V(*vp, true, d)
30848         if changed {
30849                 *vp = v
30850         }
30851 }
30852 func (_ fastpathT) DecMapInt8Int32V(v map[int8]int32, canChange bool,
30853         d *Decoder) (_ map[int8]int32, changed bool) {
30854         dd, esep := d.d, d.hh.hasElemSeparators()
30855         containerLen := dd.ReadMapStart()
30856         if canChange && v == nil {
30857                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
30858                 v = make(map[int8]int32, xlen)
30859                 changed = true
30860         }
30861         if containerLen == 0 {
30862                 dd.ReadMapEnd()
30863                 return v, changed
30864         }
30865         d.depthIncr()
30866         var mk int8
30867         var mv int32
30868         hasLen := containerLen > 0
30869         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30870                 if esep {
30871                         dd.ReadMapElemKey()
30872                 }
30873                 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30874                 if esep {
30875                         dd.ReadMapElemValue()
30876                 }
30877                 if dd.TryDecodeAsNil() {
30878                         if v == nil {
30879                         } else if d.h.DeleteOnNilMapValue {
30880                                 delete(v, mk)
30881                         } else {
30882                                 v[mk] = 0
30883                         }
30884                         continue
30885                 }
30886                 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
30887                 if v != nil {
30888                         v[mk] = mv
30889                 }
30890         }
30891         dd.ReadMapEnd()
30892         d.depthDecr()
30893         return v, changed
30894 }
30895
30896 func (d *Decoder) fastpathDecMapInt8Int64R(f *codecFnInfo, rv reflect.Value) {
30897         if rv.Kind() == reflect.Ptr {
30898                 vp := rv2i(rv).(*map[int8]int64)
30899                 v, changed := fastpathTV.DecMapInt8Int64V(*vp, true, d)
30900                 if changed {
30901                         *vp = v
30902                 }
30903         } else {
30904                 fastpathTV.DecMapInt8Int64V(rv2i(rv).(map[int8]int64), false, d)
30905         }
30906 }
30907 func (f fastpathT) DecMapInt8Int64X(vp *map[int8]int64, d *Decoder) {
30908         v, changed := f.DecMapInt8Int64V(*vp, true, d)
30909         if changed {
30910                 *vp = v
30911         }
30912 }
30913 func (_ fastpathT) DecMapInt8Int64V(v map[int8]int64, canChange bool,
30914         d *Decoder) (_ map[int8]int64, changed bool) {
30915         dd, esep := d.d, d.hh.hasElemSeparators()
30916         containerLen := dd.ReadMapStart()
30917         if canChange && v == nil {
30918                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
30919                 v = make(map[int8]int64, xlen)
30920                 changed = true
30921         }
30922         if containerLen == 0 {
30923                 dd.ReadMapEnd()
30924                 return v, changed
30925         }
30926         d.depthIncr()
30927         var mk int8
30928         var mv int64
30929         hasLen := containerLen > 0
30930         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30931                 if esep {
30932                         dd.ReadMapElemKey()
30933                 }
30934                 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30935                 if esep {
30936                         dd.ReadMapElemValue()
30937                 }
30938                 if dd.TryDecodeAsNil() {
30939                         if v == nil {
30940                         } else if d.h.DeleteOnNilMapValue {
30941                                 delete(v, mk)
30942                         } else {
30943                                 v[mk] = 0
30944                         }
30945                         continue
30946                 }
30947                 mv = dd.DecodeInt64()
30948                 if v != nil {
30949                         v[mk] = mv
30950                 }
30951         }
30952         dd.ReadMapEnd()
30953         d.depthDecr()
30954         return v, changed
30955 }
30956
30957 func (d *Decoder) fastpathDecMapInt8Float32R(f *codecFnInfo, rv reflect.Value) {
30958         if rv.Kind() == reflect.Ptr {
30959                 vp := rv2i(rv).(*map[int8]float32)
30960                 v, changed := fastpathTV.DecMapInt8Float32V(*vp, true, d)
30961                 if changed {
30962                         *vp = v
30963                 }
30964         } else {
30965                 fastpathTV.DecMapInt8Float32V(rv2i(rv).(map[int8]float32), false, d)
30966         }
30967 }
30968 func (f fastpathT) DecMapInt8Float32X(vp *map[int8]float32, d *Decoder) {
30969         v, changed := f.DecMapInt8Float32V(*vp, true, d)
30970         if changed {
30971                 *vp = v
30972         }
30973 }
30974 func (_ fastpathT) DecMapInt8Float32V(v map[int8]float32, canChange bool,
30975         d *Decoder) (_ map[int8]float32, changed bool) {
30976         dd, esep := d.d, d.hh.hasElemSeparators()
30977         containerLen := dd.ReadMapStart()
30978         if canChange && v == nil {
30979                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
30980                 v = make(map[int8]float32, xlen)
30981                 changed = true
30982         }
30983         if containerLen == 0 {
30984                 dd.ReadMapEnd()
30985                 return v, changed
30986         }
30987         d.depthIncr()
30988         var mk int8
30989         var mv float32
30990         hasLen := containerLen > 0
30991         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30992                 if esep {
30993                         dd.ReadMapElemKey()
30994                 }
30995                 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30996                 if esep {
30997                         dd.ReadMapElemValue()
30998                 }
30999                 if dd.TryDecodeAsNil() {
31000                         if v == nil {
31001                         } else if d.h.DeleteOnNilMapValue {
31002                                 delete(v, mk)
31003                         } else {
31004                                 v[mk] = 0
31005                         }
31006                         continue
31007                 }
31008                 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
31009                 if v != nil {
31010                         v[mk] = mv
31011                 }
31012         }
31013         dd.ReadMapEnd()
31014         d.depthDecr()
31015         return v, changed
31016 }
31017
31018 func (d *Decoder) fastpathDecMapInt8Float64R(f *codecFnInfo, rv reflect.Value) {
31019         if rv.Kind() == reflect.Ptr {
31020                 vp := rv2i(rv).(*map[int8]float64)
31021                 v, changed := fastpathTV.DecMapInt8Float64V(*vp, true, d)
31022                 if changed {
31023                         *vp = v
31024                 }
31025         } else {
31026                 fastpathTV.DecMapInt8Float64V(rv2i(rv).(map[int8]float64), false, d)
31027         }
31028 }
31029 func (f fastpathT) DecMapInt8Float64X(vp *map[int8]float64, d *Decoder) {
31030         v, changed := f.DecMapInt8Float64V(*vp, true, d)
31031         if changed {
31032                 *vp = v
31033         }
31034 }
31035 func (_ fastpathT) DecMapInt8Float64V(v map[int8]float64, canChange bool,
31036         d *Decoder) (_ map[int8]float64, changed bool) {
31037         dd, esep := d.d, d.hh.hasElemSeparators()
31038         containerLen := dd.ReadMapStart()
31039         if canChange && v == nil {
31040                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
31041                 v = make(map[int8]float64, xlen)
31042                 changed = true
31043         }
31044         if containerLen == 0 {
31045                 dd.ReadMapEnd()
31046                 return v, changed
31047         }
31048         d.depthIncr()
31049         var mk int8
31050         var mv float64
31051         hasLen := containerLen > 0
31052         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31053                 if esep {
31054                         dd.ReadMapElemKey()
31055                 }
31056                 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
31057                 if esep {
31058                         dd.ReadMapElemValue()
31059                 }
31060                 if dd.TryDecodeAsNil() {
31061                         if v == nil {
31062                         } else if d.h.DeleteOnNilMapValue {
31063                                 delete(v, mk)
31064                         } else {
31065                                 v[mk] = 0
31066                         }
31067                         continue
31068                 }
31069                 mv = dd.DecodeFloat64()
31070                 if v != nil {
31071                         v[mk] = mv
31072                 }
31073         }
31074         dd.ReadMapEnd()
31075         d.depthDecr()
31076         return v, changed
31077 }
31078
31079 func (d *Decoder) fastpathDecMapInt8BoolR(f *codecFnInfo, rv reflect.Value) {
31080         if rv.Kind() == reflect.Ptr {
31081                 vp := rv2i(rv).(*map[int8]bool)
31082                 v, changed := fastpathTV.DecMapInt8BoolV(*vp, true, d)
31083                 if changed {
31084                         *vp = v
31085                 }
31086         } else {
31087                 fastpathTV.DecMapInt8BoolV(rv2i(rv).(map[int8]bool), false, d)
31088         }
31089 }
31090 func (f fastpathT) DecMapInt8BoolX(vp *map[int8]bool, d *Decoder) {
31091         v, changed := f.DecMapInt8BoolV(*vp, true, d)
31092         if changed {
31093                 *vp = v
31094         }
31095 }
31096 func (_ fastpathT) DecMapInt8BoolV(v map[int8]bool, canChange bool,
31097         d *Decoder) (_ map[int8]bool, changed bool) {
31098         dd, esep := d.d, d.hh.hasElemSeparators()
31099         containerLen := dd.ReadMapStart()
31100         if canChange && v == nil {
31101                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
31102                 v = make(map[int8]bool, xlen)
31103                 changed = true
31104         }
31105         if containerLen == 0 {
31106                 dd.ReadMapEnd()
31107                 return v, changed
31108         }
31109         d.depthIncr()
31110         var mk int8
31111         var mv bool
31112         hasLen := containerLen > 0
31113         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31114                 if esep {
31115                         dd.ReadMapElemKey()
31116                 }
31117                 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
31118                 if esep {
31119                         dd.ReadMapElemValue()
31120                 }
31121                 if dd.TryDecodeAsNil() {
31122                         if v == nil {
31123                         } else if d.h.DeleteOnNilMapValue {
31124                                 delete(v, mk)
31125                         } else {
31126                                 v[mk] = false
31127                         }
31128                         continue
31129                 }
31130                 mv = dd.DecodeBool()
31131                 if v != nil {
31132                         v[mk] = mv
31133                 }
31134         }
31135         dd.ReadMapEnd()
31136         d.depthDecr()
31137         return v, changed
31138 }
31139
31140 func (d *Decoder) fastpathDecMapInt16IntfR(f *codecFnInfo, rv reflect.Value) {
31141         if rv.Kind() == reflect.Ptr {
31142                 vp := rv2i(rv).(*map[int16]interface{})
31143                 v, changed := fastpathTV.DecMapInt16IntfV(*vp, true, d)
31144                 if changed {
31145                         *vp = v
31146                 }
31147         } else {
31148                 fastpathTV.DecMapInt16IntfV(rv2i(rv).(map[int16]interface{}), false, d)
31149         }
31150 }
31151 func (f fastpathT) DecMapInt16IntfX(vp *map[int16]interface{}, d *Decoder) {
31152         v, changed := f.DecMapInt16IntfV(*vp, true, d)
31153         if changed {
31154                 *vp = v
31155         }
31156 }
31157 func (_ fastpathT) DecMapInt16IntfV(v map[int16]interface{}, canChange bool,
31158         d *Decoder) (_ map[int16]interface{}, changed bool) {
31159         dd, esep := d.d, d.hh.hasElemSeparators()
31160         containerLen := dd.ReadMapStart()
31161         if canChange && v == nil {
31162                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
31163                 v = make(map[int16]interface{}, xlen)
31164                 changed = true
31165         }
31166         if containerLen == 0 {
31167                 dd.ReadMapEnd()
31168                 return v, changed
31169         }
31170         d.depthIncr()
31171         mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
31172         var mk int16
31173         var mv interface{}
31174         hasLen := containerLen > 0
31175         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31176                 if esep {
31177                         dd.ReadMapElemKey()
31178                 }
31179                 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31180                 if esep {
31181                         dd.ReadMapElemValue()
31182                 }
31183                 if dd.TryDecodeAsNil() {
31184                         if v == nil {
31185                         } else if d.h.DeleteOnNilMapValue {
31186                                 delete(v, mk)
31187                         } else {
31188                                 v[mk] = nil
31189                         }
31190                         continue
31191                 }
31192                 if mapGet {
31193                         mv = v[mk]
31194                 } else {
31195                         mv = nil
31196                 }
31197                 d.decode(&mv)
31198                 if v != nil {
31199                         v[mk] = mv
31200                 }
31201         }
31202         dd.ReadMapEnd()
31203         d.depthDecr()
31204         return v, changed
31205 }
31206
31207 func (d *Decoder) fastpathDecMapInt16StringR(f *codecFnInfo, rv reflect.Value) {
31208         if rv.Kind() == reflect.Ptr {
31209                 vp := rv2i(rv).(*map[int16]string)
31210                 v, changed := fastpathTV.DecMapInt16StringV(*vp, true, d)
31211                 if changed {
31212                         *vp = v
31213                 }
31214         } else {
31215                 fastpathTV.DecMapInt16StringV(rv2i(rv).(map[int16]string), false, d)
31216         }
31217 }
31218 func (f fastpathT) DecMapInt16StringX(vp *map[int16]string, d *Decoder) {
31219         v, changed := f.DecMapInt16StringV(*vp, true, d)
31220         if changed {
31221                 *vp = v
31222         }
31223 }
31224 func (_ fastpathT) DecMapInt16StringV(v map[int16]string, canChange bool,
31225         d *Decoder) (_ map[int16]string, changed bool) {
31226         dd, esep := d.d, d.hh.hasElemSeparators()
31227         containerLen := dd.ReadMapStart()
31228         if canChange && v == nil {
31229                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
31230                 v = make(map[int16]string, xlen)
31231                 changed = true
31232         }
31233         if containerLen == 0 {
31234                 dd.ReadMapEnd()
31235                 return v, changed
31236         }
31237         d.depthIncr()
31238         var mk int16
31239         var mv string
31240         hasLen := containerLen > 0
31241         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31242                 if esep {
31243                         dd.ReadMapElemKey()
31244                 }
31245                 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31246                 if esep {
31247                         dd.ReadMapElemValue()
31248                 }
31249                 if dd.TryDecodeAsNil() {
31250                         if v == nil {
31251                         } else if d.h.DeleteOnNilMapValue {
31252                                 delete(v, mk)
31253                         } else {
31254                                 v[mk] = ""
31255                         }
31256                         continue
31257                 }
31258                 mv = dd.DecodeString()
31259                 if v != nil {
31260                         v[mk] = mv
31261                 }
31262         }
31263         dd.ReadMapEnd()
31264         d.depthDecr()
31265         return v, changed
31266 }
31267
31268 func (d *Decoder) fastpathDecMapInt16UintR(f *codecFnInfo, rv reflect.Value) {
31269         if rv.Kind() == reflect.Ptr {
31270                 vp := rv2i(rv).(*map[int16]uint)
31271                 v, changed := fastpathTV.DecMapInt16UintV(*vp, true, d)
31272                 if changed {
31273                         *vp = v
31274                 }
31275         } else {
31276                 fastpathTV.DecMapInt16UintV(rv2i(rv).(map[int16]uint), false, d)
31277         }
31278 }
31279 func (f fastpathT) DecMapInt16UintX(vp *map[int16]uint, d *Decoder) {
31280         v, changed := f.DecMapInt16UintV(*vp, true, d)
31281         if changed {
31282                 *vp = v
31283         }
31284 }
31285 func (_ fastpathT) DecMapInt16UintV(v map[int16]uint, canChange bool,
31286         d *Decoder) (_ map[int16]uint, changed bool) {
31287         dd, esep := d.d, d.hh.hasElemSeparators()
31288         containerLen := dd.ReadMapStart()
31289         if canChange && v == nil {
31290                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
31291                 v = make(map[int16]uint, xlen)
31292                 changed = true
31293         }
31294         if containerLen == 0 {
31295                 dd.ReadMapEnd()
31296                 return v, changed
31297         }
31298         d.depthIncr()
31299         var mk int16
31300         var mv uint
31301         hasLen := containerLen > 0
31302         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31303                 if esep {
31304                         dd.ReadMapElemKey()
31305                 }
31306                 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31307                 if esep {
31308                         dd.ReadMapElemValue()
31309                 }
31310                 if dd.TryDecodeAsNil() {
31311                         if v == nil {
31312                         } else if d.h.DeleteOnNilMapValue {
31313                                 delete(v, mk)
31314                         } else {
31315                                 v[mk] = 0
31316                         }
31317                         continue
31318                 }
31319                 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
31320                 if v != nil {
31321                         v[mk] = mv
31322                 }
31323         }
31324         dd.ReadMapEnd()
31325         d.depthDecr()
31326         return v, changed
31327 }
31328
31329 func (d *Decoder) fastpathDecMapInt16Uint8R(f *codecFnInfo, rv reflect.Value) {
31330         if rv.Kind() == reflect.Ptr {
31331                 vp := rv2i(rv).(*map[int16]uint8)
31332                 v, changed := fastpathTV.DecMapInt16Uint8V(*vp, true, d)
31333                 if changed {
31334                         *vp = v
31335                 }
31336         } else {
31337                 fastpathTV.DecMapInt16Uint8V(rv2i(rv).(map[int16]uint8), false, d)
31338         }
31339 }
31340 func (f fastpathT) DecMapInt16Uint8X(vp *map[int16]uint8, d *Decoder) {
31341         v, changed := f.DecMapInt16Uint8V(*vp, true, d)
31342         if changed {
31343                 *vp = v
31344         }
31345 }
31346 func (_ fastpathT) DecMapInt16Uint8V(v map[int16]uint8, canChange bool,
31347         d *Decoder) (_ map[int16]uint8, changed bool) {
31348         dd, esep := d.d, d.hh.hasElemSeparators()
31349         containerLen := dd.ReadMapStart()
31350         if canChange && v == nil {
31351                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
31352                 v = make(map[int16]uint8, xlen)
31353                 changed = true
31354         }
31355         if containerLen == 0 {
31356                 dd.ReadMapEnd()
31357                 return v, changed
31358         }
31359         d.depthIncr()
31360         var mk int16
31361         var mv uint8
31362         hasLen := containerLen > 0
31363         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31364                 if esep {
31365                         dd.ReadMapElemKey()
31366                 }
31367                 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31368                 if esep {
31369                         dd.ReadMapElemValue()
31370                 }
31371                 if dd.TryDecodeAsNil() {
31372                         if v == nil {
31373                         } else if d.h.DeleteOnNilMapValue {
31374                                 delete(v, mk)
31375                         } else {
31376                                 v[mk] = 0
31377                         }
31378                         continue
31379                 }
31380                 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
31381                 if v != nil {
31382                         v[mk] = mv
31383                 }
31384         }
31385         dd.ReadMapEnd()
31386         d.depthDecr()
31387         return v, changed
31388 }
31389
31390 func (d *Decoder) fastpathDecMapInt16Uint16R(f *codecFnInfo, rv reflect.Value) {
31391         if rv.Kind() == reflect.Ptr {
31392                 vp := rv2i(rv).(*map[int16]uint16)
31393                 v, changed := fastpathTV.DecMapInt16Uint16V(*vp, true, d)
31394                 if changed {
31395                         *vp = v
31396                 }
31397         } else {
31398                 fastpathTV.DecMapInt16Uint16V(rv2i(rv).(map[int16]uint16), false, d)
31399         }
31400 }
31401 func (f fastpathT) DecMapInt16Uint16X(vp *map[int16]uint16, d *Decoder) {
31402         v, changed := f.DecMapInt16Uint16V(*vp, true, d)
31403         if changed {
31404                 *vp = v
31405         }
31406 }
31407 func (_ fastpathT) DecMapInt16Uint16V(v map[int16]uint16, canChange bool,
31408         d *Decoder) (_ map[int16]uint16, changed bool) {
31409         dd, esep := d.d, d.hh.hasElemSeparators()
31410         containerLen := dd.ReadMapStart()
31411         if canChange && v == nil {
31412                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 4)
31413                 v = make(map[int16]uint16, xlen)
31414                 changed = true
31415         }
31416         if containerLen == 0 {
31417                 dd.ReadMapEnd()
31418                 return v, changed
31419         }
31420         d.depthIncr()
31421         var mk int16
31422         var mv uint16
31423         hasLen := containerLen > 0
31424         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31425                 if esep {
31426                         dd.ReadMapElemKey()
31427                 }
31428                 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31429                 if esep {
31430                         dd.ReadMapElemValue()
31431                 }
31432                 if dd.TryDecodeAsNil() {
31433                         if v == nil {
31434                         } else if d.h.DeleteOnNilMapValue {
31435                                 delete(v, mk)
31436                         } else {
31437                                 v[mk] = 0
31438                         }
31439                         continue
31440                 }
31441                 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
31442                 if v != nil {
31443                         v[mk] = mv
31444                 }
31445         }
31446         dd.ReadMapEnd()
31447         d.depthDecr()
31448         return v, changed
31449 }
31450
31451 func (d *Decoder) fastpathDecMapInt16Uint32R(f *codecFnInfo, rv reflect.Value) {
31452         if rv.Kind() == reflect.Ptr {
31453                 vp := rv2i(rv).(*map[int16]uint32)
31454                 v, changed := fastpathTV.DecMapInt16Uint32V(*vp, true, d)
31455                 if changed {
31456                         *vp = v
31457                 }
31458         } else {
31459                 fastpathTV.DecMapInt16Uint32V(rv2i(rv).(map[int16]uint32), false, d)
31460         }
31461 }
31462 func (f fastpathT) DecMapInt16Uint32X(vp *map[int16]uint32, d *Decoder) {
31463         v, changed := f.DecMapInt16Uint32V(*vp, true, d)
31464         if changed {
31465                 *vp = v
31466         }
31467 }
31468 func (_ fastpathT) DecMapInt16Uint32V(v map[int16]uint32, canChange bool,
31469         d *Decoder) (_ map[int16]uint32, changed bool) {
31470         dd, esep := d.d, d.hh.hasElemSeparators()
31471         containerLen := dd.ReadMapStart()
31472         if canChange && v == nil {
31473                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
31474                 v = make(map[int16]uint32, xlen)
31475                 changed = true
31476         }
31477         if containerLen == 0 {
31478                 dd.ReadMapEnd()
31479                 return v, changed
31480         }
31481         d.depthIncr()
31482         var mk int16
31483         var mv uint32
31484         hasLen := containerLen > 0
31485         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31486                 if esep {
31487                         dd.ReadMapElemKey()
31488                 }
31489                 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31490                 if esep {
31491                         dd.ReadMapElemValue()
31492                 }
31493                 if dd.TryDecodeAsNil() {
31494                         if v == nil {
31495                         } else if d.h.DeleteOnNilMapValue {
31496                                 delete(v, mk)
31497                         } else {
31498                                 v[mk] = 0
31499                         }
31500                         continue
31501                 }
31502                 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
31503                 if v != nil {
31504                         v[mk] = mv
31505                 }
31506         }
31507         dd.ReadMapEnd()
31508         d.depthDecr()
31509         return v, changed
31510 }
31511
31512 func (d *Decoder) fastpathDecMapInt16Uint64R(f *codecFnInfo, rv reflect.Value) {
31513         if rv.Kind() == reflect.Ptr {
31514                 vp := rv2i(rv).(*map[int16]uint64)
31515                 v, changed := fastpathTV.DecMapInt16Uint64V(*vp, true, d)
31516                 if changed {
31517                         *vp = v
31518                 }
31519         } else {
31520                 fastpathTV.DecMapInt16Uint64V(rv2i(rv).(map[int16]uint64), false, d)
31521         }
31522 }
31523 func (f fastpathT) DecMapInt16Uint64X(vp *map[int16]uint64, d *Decoder) {
31524         v, changed := f.DecMapInt16Uint64V(*vp, true, d)
31525         if changed {
31526                 *vp = v
31527         }
31528 }
31529 func (_ fastpathT) DecMapInt16Uint64V(v map[int16]uint64, canChange bool,
31530         d *Decoder) (_ map[int16]uint64, changed bool) {
31531         dd, esep := d.d, d.hh.hasElemSeparators()
31532         containerLen := dd.ReadMapStart()
31533         if canChange && v == nil {
31534                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
31535                 v = make(map[int16]uint64, xlen)
31536                 changed = true
31537         }
31538         if containerLen == 0 {
31539                 dd.ReadMapEnd()
31540                 return v, changed
31541         }
31542         d.depthIncr()
31543         var mk int16
31544         var mv uint64
31545         hasLen := containerLen > 0
31546         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31547                 if esep {
31548                         dd.ReadMapElemKey()
31549                 }
31550                 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31551                 if esep {
31552                         dd.ReadMapElemValue()
31553                 }
31554                 if dd.TryDecodeAsNil() {
31555                         if v == nil {
31556                         } else if d.h.DeleteOnNilMapValue {
31557                                 delete(v, mk)
31558                         } else {
31559                                 v[mk] = 0
31560                         }
31561                         continue
31562                 }
31563                 mv = dd.DecodeUint64()
31564                 if v != nil {
31565                         v[mk] = mv
31566                 }
31567         }
31568         dd.ReadMapEnd()
31569         d.depthDecr()
31570         return v, changed
31571 }
31572
31573 func (d *Decoder) fastpathDecMapInt16UintptrR(f *codecFnInfo, rv reflect.Value) {
31574         if rv.Kind() == reflect.Ptr {
31575                 vp := rv2i(rv).(*map[int16]uintptr)
31576                 v, changed := fastpathTV.DecMapInt16UintptrV(*vp, true, d)
31577                 if changed {
31578                         *vp = v
31579                 }
31580         } else {
31581                 fastpathTV.DecMapInt16UintptrV(rv2i(rv).(map[int16]uintptr), false, d)
31582         }
31583 }
31584 func (f fastpathT) DecMapInt16UintptrX(vp *map[int16]uintptr, d *Decoder) {
31585         v, changed := f.DecMapInt16UintptrV(*vp, true, d)
31586         if changed {
31587                 *vp = v
31588         }
31589 }
31590 func (_ fastpathT) DecMapInt16UintptrV(v map[int16]uintptr, canChange bool,
31591         d *Decoder) (_ map[int16]uintptr, changed bool) {
31592         dd, esep := d.d, d.hh.hasElemSeparators()
31593         containerLen := dd.ReadMapStart()
31594         if canChange && v == nil {
31595                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
31596                 v = make(map[int16]uintptr, xlen)
31597                 changed = true
31598         }
31599         if containerLen == 0 {
31600                 dd.ReadMapEnd()
31601                 return v, changed
31602         }
31603         d.depthIncr()
31604         var mk int16
31605         var mv uintptr
31606         hasLen := containerLen > 0
31607         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31608                 if esep {
31609                         dd.ReadMapElemKey()
31610                 }
31611                 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31612                 if esep {
31613                         dd.ReadMapElemValue()
31614                 }
31615                 if dd.TryDecodeAsNil() {
31616                         if v == nil {
31617                         } else if d.h.DeleteOnNilMapValue {
31618                                 delete(v, mk)
31619                         } else {
31620                                 v[mk] = 0
31621                         }
31622                         continue
31623                 }
31624                 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
31625                 if v != nil {
31626                         v[mk] = mv
31627                 }
31628         }
31629         dd.ReadMapEnd()
31630         d.depthDecr()
31631         return v, changed
31632 }
31633
31634 func (d *Decoder) fastpathDecMapInt16IntR(f *codecFnInfo, rv reflect.Value) {
31635         if rv.Kind() == reflect.Ptr {
31636                 vp := rv2i(rv).(*map[int16]int)
31637                 v, changed := fastpathTV.DecMapInt16IntV(*vp, true, d)
31638                 if changed {
31639                         *vp = v
31640                 }
31641         } else {
31642                 fastpathTV.DecMapInt16IntV(rv2i(rv).(map[int16]int), false, d)
31643         }
31644 }
31645 func (f fastpathT) DecMapInt16IntX(vp *map[int16]int, d *Decoder) {
31646         v, changed := f.DecMapInt16IntV(*vp, true, d)
31647         if changed {
31648                 *vp = v
31649         }
31650 }
31651 func (_ fastpathT) DecMapInt16IntV(v map[int16]int, canChange bool,
31652         d *Decoder) (_ map[int16]int, changed bool) {
31653         dd, esep := d.d, d.hh.hasElemSeparators()
31654         containerLen := dd.ReadMapStart()
31655         if canChange && v == nil {
31656                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
31657                 v = make(map[int16]int, xlen)
31658                 changed = true
31659         }
31660         if containerLen == 0 {
31661                 dd.ReadMapEnd()
31662                 return v, changed
31663         }
31664         d.depthIncr()
31665         var mk int16
31666         var mv int
31667         hasLen := containerLen > 0
31668         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31669                 if esep {
31670                         dd.ReadMapElemKey()
31671                 }
31672                 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31673                 if esep {
31674                         dd.ReadMapElemValue()
31675                 }
31676                 if dd.TryDecodeAsNil() {
31677                         if v == nil {
31678                         } else if d.h.DeleteOnNilMapValue {
31679                                 delete(v, mk)
31680                         } else {
31681                                 v[mk] = 0
31682                         }
31683                         continue
31684                 }
31685                 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
31686                 if v != nil {
31687                         v[mk] = mv
31688                 }
31689         }
31690         dd.ReadMapEnd()
31691         d.depthDecr()
31692         return v, changed
31693 }
31694
31695 func (d *Decoder) fastpathDecMapInt16Int8R(f *codecFnInfo, rv reflect.Value) {
31696         if rv.Kind() == reflect.Ptr {
31697                 vp := rv2i(rv).(*map[int16]int8)
31698                 v, changed := fastpathTV.DecMapInt16Int8V(*vp, true, d)
31699                 if changed {
31700                         *vp = v
31701                 }
31702         } else {
31703                 fastpathTV.DecMapInt16Int8V(rv2i(rv).(map[int16]int8), false, d)
31704         }
31705 }
31706 func (f fastpathT) DecMapInt16Int8X(vp *map[int16]int8, d *Decoder) {
31707         v, changed := f.DecMapInt16Int8V(*vp, true, d)
31708         if changed {
31709                 *vp = v
31710         }
31711 }
31712 func (_ fastpathT) DecMapInt16Int8V(v map[int16]int8, canChange bool,
31713         d *Decoder) (_ map[int16]int8, changed bool) {
31714         dd, esep := d.d, d.hh.hasElemSeparators()
31715         containerLen := dd.ReadMapStart()
31716         if canChange && v == nil {
31717                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
31718                 v = make(map[int16]int8, xlen)
31719                 changed = true
31720         }
31721         if containerLen == 0 {
31722                 dd.ReadMapEnd()
31723                 return v, changed
31724         }
31725         d.depthIncr()
31726         var mk int16
31727         var mv int8
31728         hasLen := containerLen > 0
31729         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31730                 if esep {
31731                         dd.ReadMapElemKey()
31732                 }
31733                 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31734                 if esep {
31735                         dd.ReadMapElemValue()
31736                 }
31737                 if dd.TryDecodeAsNil() {
31738                         if v == nil {
31739                         } else if d.h.DeleteOnNilMapValue {
31740                                 delete(v, mk)
31741                         } else {
31742                                 v[mk] = 0
31743                         }
31744                         continue
31745                 }
31746                 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
31747                 if v != nil {
31748                         v[mk] = mv
31749                 }
31750         }
31751         dd.ReadMapEnd()
31752         d.depthDecr()
31753         return v, changed
31754 }
31755
31756 func (d *Decoder) fastpathDecMapInt16Int16R(f *codecFnInfo, rv reflect.Value) {
31757         if rv.Kind() == reflect.Ptr {
31758                 vp := rv2i(rv).(*map[int16]int16)
31759                 v, changed := fastpathTV.DecMapInt16Int16V(*vp, true, d)
31760                 if changed {
31761                         *vp = v
31762                 }
31763         } else {
31764                 fastpathTV.DecMapInt16Int16V(rv2i(rv).(map[int16]int16), false, d)
31765         }
31766 }
31767 func (f fastpathT) DecMapInt16Int16X(vp *map[int16]int16, d *Decoder) {
31768         v, changed := f.DecMapInt16Int16V(*vp, true, d)
31769         if changed {
31770                 *vp = v
31771         }
31772 }
31773 func (_ fastpathT) DecMapInt16Int16V(v map[int16]int16, canChange bool,
31774         d *Decoder) (_ map[int16]int16, changed bool) {
31775         dd, esep := d.d, d.hh.hasElemSeparators()
31776         containerLen := dd.ReadMapStart()
31777         if canChange && v == nil {
31778                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 4)
31779                 v = make(map[int16]int16, xlen)
31780                 changed = true
31781         }
31782         if containerLen == 0 {
31783                 dd.ReadMapEnd()
31784                 return v, changed
31785         }
31786         d.depthIncr()
31787         var mk int16
31788         var mv int16
31789         hasLen := containerLen > 0
31790         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31791                 if esep {
31792                         dd.ReadMapElemKey()
31793                 }
31794                 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31795                 if esep {
31796                         dd.ReadMapElemValue()
31797                 }
31798                 if dd.TryDecodeAsNil() {
31799                         if v == nil {
31800                         } else if d.h.DeleteOnNilMapValue {
31801                                 delete(v, mk)
31802                         } else {
31803                                 v[mk] = 0
31804                         }
31805                         continue
31806                 }
31807                 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31808                 if v != nil {
31809                         v[mk] = mv
31810                 }
31811         }
31812         dd.ReadMapEnd()
31813         d.depthDecr()
31814         return v, changed
31815 }
31816
31817 func (d *Decoder) fastpathDecMapInt16Int32R(f *codecFnInfo, rv reflect.Value) {
31818         if rv.Kind() == reflect.Ptr {
31819                 vp := rv2i(rv).(*map[int16]int32)
31820                 v, changed := fastpathTV.DecMapInt16Int32V(*vp, true, d)
31821                 if changed {
31822                         *vp = v
31823                 }
31824         } else {
31825                 fastpathTV.DecMapInt16Int32V(rv2i(rv).(map[int16]int32), false, d)
31826         }
31827 }
31828 func (f fastpathT) DecMapInt16Int32X(vp *map[int16]int32, d *Decoder) {
31829         v, changed := f.DecMapInt16Int32V(*vp, true, d)
31830         if changed {
31831                 *vp = v
31832         }
31833 }
31834 func (_ fastpathT) DecMapInt16Int32V(v map[int16]int32, canChange bool,
31835         d *Decoder) (_ map[int16]int32, changed bool) {
31836         dd, esep := d.d, d.hh.hasElemSeparators()
31837         containerLen := dd.ReadMapStart()
31838         if canChange && v == nil {
31839                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
31840                 v = make(map[int16]int32, xlen)
31841                 changed = true
31842         }
31843         if containerLen == 0 {
31844                 dd.ReadMapEnd()
31845                 return v, changed
31846         }
31847         d.depthIncr()
31848         var mk int16
31849         var mv int32
31850         hasLen := containerLen > 0
31851         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31852                 if esep {
31853                         dd.ReadMapElemKey()
31854                 }
31855                 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31856                 if esep {
31857                         dd.ReadMapElemValue()
31858                 }
31859                 if dd.TryDecodeAsNil() {
31860                         if v == nil {
31861                         } else if d.h.DeleteOnNilMapValue {
31862                                 delete(v, mk)
31863                         } else {
31864                                 v[mk] = 0
31865                         }
31866                         continue
31867                 }
31868                 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
31869                 if v != nil {
31870                         v[mk] = mv
31871                 }
31872         }
31873         dd.ReadMapEnd()
31874         d.depthDecr()
31875         return v, changed
31876 }
31877
31878 func (d *Decoder) fastpathDecMapInt16Int64R(f *codecFnInfo, rv reflect.Value) {
31879         if rv.Kind() == reflect.Ptr {
31880                 vp := rv2i(rv).(*map[int16]int64)
31881                 v, changed := fastpathTV.DecMapInt16Int64V(*vp, true, d)
31882                 if changed {
31883                         *vp = v
31884                 }
31885         } else {
31886                 fastpathTV.DecMapInt16Int64V(rv2i(rv).(map[int16]int64), false, d)
31887         }
31888 }
31889 func (f fastpathT) DecMapInt16Int64X(vp *map[int16]int64, d *Decoder) {
31890         v, changed := f.DecMapInt16Int64V(*vp, true, d)
31891         if changed {
31892                 *vp = v
31893         }
31894 }
31895 func (_ fastpathT) DecMapInt16Int64V(v map[int16]int64, canChange bool,
31896         d *Decoder) (_ map[int16]int64, changed bool) {
31897         dd, esep := d.d, d.hh.hasElemSeparators()
31898         containerLen := dd.ReadMapStart()
31899         if canChange && v == nil {
31900                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
31901                 v = make(map[int16]int64, xlen)
31902                 changed = true
31903         }
31904         if containerLen == 0 {
31905                 dd.ReadMapEnd()
31906                 return v, changed
31907         }
31908         d.depthIncr()
31909         var mk int16
31910         var mv int64
31911         hasLen := containerLen > 0
31912         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31913                 if esep {
31914                         dd.ReadMapElemKey()
31915                 }
31916                 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31917                 if esep {
31918                         dd.ReadMapElemValue()
31919                 }
31920                 if dd.TryDecodeAsNil() {
31921                         if v == nil {
31922                         } else if d.h.DeleteOnNilMapValue {
31923                                 delete(v, mk)
31924                         } else {
31925                                 v[mk] = 0
31926                         }
31927                         continue
31928                 }
31929                 mv = dd.DecodeInt64()
31930                 if v != nil {
31931                         v[mk] = mv
31932                 }
31933         }
31934         dd.ReadMapEnd()
31935         d.depthDecr()
31936         return v, changed
31937 }
31938
31939 func (d *Decoder) fastpathDecMapInt16Float32R(f *codecFnInfo, rv reflect.Value) {
31940         if rv.Kind() == reflect.Ptr {
31941                 vp := rv2i(rv).(*map[int16]float32)
31942                 v, changed := fastpathTV.DecMapInt16Float32V(*vp, true, d)
31943                 if changed {
31944                         *vp = v
31945                 }
31946         } else {
31947                 fastpathTV.DecMapInt16Float32V(rv2i(rv).(map[int16]float32), false, d)
31948         }
31949 }
31950 func (f fastpathT) DecMapInt16Float32X(vp *map[int16]float32, d *Decoder) {
31951         v, changed := f.DecMapInt16Float32V(*vp, true, d)
31952         if changed {
31953                 *vp = v
31954         }
31955 }
31956 func (_ fastpathT) DecMapInt16Float32V(v map[int16]float32, canChange bool,
31957         d *Decoder) (_ map[int16]float32, changed bool) {
31958         dd, esep := d.d, d.hh.hasElemSeparators()
31959         containerLen := dd.ReadMapStart()
31960         if canChange && v == nil {
31961                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
31962                 v = make(map[int16]float32, xlen)
31963                 changed = true
31964         }
31965         if containerLen == 0 {
31966                 dd.ReadMapEnd()
31967                 return v, changed
31968         }
31969         d.depthIncr()
31970         var mk int16
31971         var mv float32
31972         hasLen := containerLen > 0
31973         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31974                 if esep {
31975                         dd.ReadMapElemKey()
31976                 }
31977                 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31978                 if esep {
31979                         dd.ReadMapElemValue()
31980                 }
31981                 if dd.TryDecodeAsNil() {
31982                         if v == nil {
31983                         } else if d.h.DeleteOnNilMapValue {
31984                                 delete(v, mk)
31985                         } else {
31986                                 v[mk] = 0
31987                         }
31988                         continue
31989                 }
31990                 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
31991                 if v != nil {
31992                         v[mk] = mv
31993                 }
31994         }
31995         dd.ReadMapEnd()
31996         d.depthDecr()
31997         return v, changed
31998 }
31999
32000 func (d *Decoder) fastpathDecMapInt16Float64R(f *codecFnInfo, rv reflect.Value) {
32001         if rv.Kind() == reflect.Ptr {
32002                 vp := rv2i(rv).(*map[int16]float64)
32003                 v, changed := fastpathTV.DecMapInt16Float64V(*vp, true, d)
32004                 if changed {
32005                         *vp = v
32006                 }
32007         } else {
32008                 fastpathTV.DecMapInt16Float64V(rv2i(rv).(map[int16]float64), false, d)
32009         }
32010 }
32011 func (f fastpathT) DecMapInt16Float64X(vp *map[int16]float64, d *Decoder) {
32012         v, changed := f.DecMapInt16Float64V(*vp, true, d)
32013         if changed {
32014                 *vp = v
32015         }
32016 }
32017 func (_ fastpathT) DecMapInt16Float64V(v map[int16]float64, canChange bool,
32018         d *Decoder) (_ map[int16]float64, changed bool) {
32019         dd, esep := d.d, d.hh.hasElemSeparators()
32020         containerLen := dd.ReadMapStart()
32021         if canChange && v == nil {
32022                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
32023                 v = make(map[int16]float64, xlen)
32024                 changed = true
32025         }
32026         if containerLen == 0 {
32027                 dd.ReadMapEnd()
32028                 return v, changed
32029         }
32030         d.depthIncr()
32031         var mk int16
32032         var mv float64
32033         hasLen := containerLen > 0
32034         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32035                 if esep {
32036                         dd.ReadMapElemKey()
32037                 }
32038                 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
32039                 if esep {
32040                         dd.ReadMapElemValue()
32041                 }
32042                 if dd.TryDecodeAsNil() {
32043                         if v == nil {
32044                         } else if d.h.DeleteOnNilMapValue {
32045                                 delete(v, mk)
32046                         } else {
32047                                 v[mk] = 0
32048                         }
32049                         continue
32050                 }
32051                 mv = dd.DecodeFloat64()
32052                 if v != nil {
32053                         v[mk] = mv
32054                 }
32055         }
32056         dd.ReadMapEnd()
32057         d.depthDecr()
32058         return v, changed
32059 }
32060
32061 func (d *Decoder) fastpathDecMapInt16BoolR(f *codecFnInfo, rv reflect.Value) {
32062         if rv.Kind() == reflect.Ptr {
32063                 vp := rv2i(rv).(*map[int16]bool)
32064                 v, changed := fastpathTV.DecMapInt16BoolV(*vp, true, d)
32065                 if changed {
32066                         *vp = v
32067                 }
32068         } else {
32069                 fastpathTV.DecMapInt16BoolV(rv2i(rv).(map[int16]bool), false, d)
32070         }
32071 }
32072 func (f fastpathT) DecMapInt16BoolX(vp *map[int16]bool, d *Decoder) {
32073         v, changed := f.DecMapInt16BoolV(*vp, true, d)
32074         if changed {
32075                 *vp = v
32076         }
32077 }
32078 func (_ fastpathT) DecMapInt16BoolV(v map[int16]bool, canChange bool,
32079         d *Decoder) (_ map[int16]bool, changed bool) {
32080         dd, esep := d.d, d.hh.hasElemSeparators()
32081         containerLen := dd.ReadMapStart()
32082         if canChange && v == nil {
32083                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
32084                 v = make(map[int16]bool, xlen)
32085                 changed = true
32086         }
32087         if containerLen == 0 {
32088                 dd.ReadMapEnd()
32089                 return v, changed
32090         }
32091         d.depthIncr()
32092         var mk int16
32093         var mv bool
32094         hasLen := containerLen > 0
32095         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32096                 if esep {
32097                         dd.ReadMapElemKey()
32098                 }
32099                 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
32100                 if esep {
32101                         dd.ReadMapElemValue()
32102                 }
32103                 if dd.TryDecodeAsNil() {
32104                         if v == nil {
32105                         } else if d.h.DeleteOnNilMapValue {
32106                                 delete(v, mk)
32107                         } else {
32108                                 v[mk] = false
32109                         }
32110                         continue
32111                 }
32112                 mv = dd.DecodeBool()
32113                 if v != nil {
32114                         v[mk] = mv
32115                 }
32116         }
32117         dd.ReadMapEnd()
32118         d.depthDecr()
32119         return v, changed
32120 }
32121
32122 func (d *Decoder) fastpathDecMapInt32IntfR(f *codecFnInfo, rv reflect.Value) {
32123         if rv.Kind() == reflect.Ptr {
32124                 vp := rv2i(rv).(*map[int32]interface{})
32125                 v, changed := fastpathTV.DecMapInt32IntfV(*vp, true, d)
32126                 if changed {
32127                         *vp = v
32128                 }
32129         } else {
32130                 fastpathTV.DecMapInt32IntfV(rv2i(rv).(map[int32]interface{}), false, d)
32131         }
32132 }
32133 func (f fastpathT) DecMapInt32IntfX(vp *map[int32]interface{}, d *Decoder) {
32134         v, changed := f.DecMapInt32IntfV(*vp, true, d)
32135         if changed {
32136                 *vp = v
32137         }
32138 }
32139 func (_ fastpathT) DecMapInt32IntfV(v map[int32]interface{}, canChange bool,
32140         d *Decoder) (_ map[int32]interface{}, changed bool) {
32141         dd, esep := d.d, d.hh.hasElemSeparators()
32142         containerLen := dd.ReadMapStart()
32143         if canChange && v == nil {
32144                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
32145                 v = make(map[int32]interface{}, xlen)
32146                 changed = true
32147         }
32148         if containerLen == 0 {
32149                 dd.ReadMapEnd()
32150                 return v, changed
32151         }
32152         d.depthIncr()
32153         mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
32154         var mk int32
32155         var mv interface{}
32156         hasLen := containerLen > 0
32157         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32158                 if esep {
32159                         dd.ReadMapElemKey()
32160                 }
32161                 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32162                 if esep {
32163                         dd.ReadMapElemValue()
32164                 }
32165                 if dd.TryDecodeAsNil() {
32166                         if v == nil {
32167                         } else if d.h.DeleteOnNilMapValue {
32168                                 delete(v, mk)
32169                         } else {
32170                                 v[mk] = nil
32171                         }
32172                         continue
32173                 }
32174                 if mapGet {
32175                         mv = v[mk]
32176                 } else {
32177                         mv = nil
32178                 }
32179                 d.decode(&mv)
32180                 if v != nil {
32181                         v[mk] = mv
32182                 }
32183         }
32184         dd.ReadMapEnd()
32185         d.depthDecr()
32186         return v, changed
32187 }
32188
32189 func (d *Decoder) fastpathDecMapInt32StringR(f *codecFnInfo, rv reflect.Value) {
32190         if rv.Kind() == reflect.Ptr {
32191                 vp := rv2i(rv).(*map[int32]string)
32192                 v, changed := fastpathTV.DecMapInt32StringV(*vp, true, d)
32193                 if changed {
32194                         *vp = v
32195                 }
32196         } else {
32197                 fastpathTV.DecMapInt32StringV(rv2i(rv).(map[int32]string), false, d)
32198         }
32199 }
32200 func (f fastpathT) DecMapInt32StringX(vp *map[int32]string, d *Decoder) {
32201         v, changed := f.DecMapInt32StringV(*vp, true, d)
32202         if changed {
32203                 *vp = v
32204         }
32205 }
32206 func (_ fastpathT) DecMapInt32StringV(v map[int32]string, canChange bool,
32207         d *Decoder) (_ map[int32]string, changed bool) {
32208         dd, esep := d.d, d.hh.hasElemSeparators()
32209         containerLen := dd.ReadMapStart()
32210         if canChange && v == nil {
32211                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
32212                 v = make(map[int32]string, xlen)
32213                 changed = true
32214         }
32215         if containerLen == 0 {
32216                 dd.ReadMapEnd()
32217                 return v, changed
32218         }
32219         d.depthIncr()
32220         var mk int32
32221         var mv string
32222         hasLen := containerLen > 0
32223         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32224                 if esep {
32225                         dd.ReadMapElemKey()
32226                 }
32227                 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32228                 if esep {
32229                         dd.ReadMapElemValue()
32230                 }
32231                 if dd.TryDecodeAsNil() {
32232                         if v == nil {
32233                         } else if d.h.DeleteOnNilMapValue {
32234                                 delete(v, mk)
32235                         } else {
32236                                 v[mk] = ""
32237                         }
32238                         continue
32239                 }
32240                 mv = dd.DecodeString()
32241                 if v != nil {
32242                         v[mk] = mv
32243                 }
32244         }
32245         dd.ReadMapEnd()
32246         d.depthDecr()
32247         return v, changed
32248 }
32249
32250 func (d *Decoder) fastpathDecMapInt32UintR(f *codecFnInfo, rv reflect.Value) {
32251         if rv.Kind() == reflect.Ptr {
32252                 vp := rv2i(rv).(*map[int32]uint)
32253                 v, changed := fastpathTV.DecMapInt32UintV(*vp, true, d)
32254                 if changed {
32255                         *vp = v
32256                 }
32257         } else {
32258                 fastpathTV.DecMapInt32UintV(rv2i(rv).(map[int32]uint), false, d)
32259         }
32260 }
32261 func (f fastpathT) DecMapInt32UintX(vp *map[int32]uint, d *Decoder) {
32262         v, changed := f.DecMapInt32UintV(*vp, true, d)
32263         if changed {
32264                 *vp = v
32265         }
32266 }
32267 func (_ fastpathT) DecMapInt32UintV(v map[int32]uint, canChange bool,
32268         d *Decoder) (_ map[int32]uint, changed bool) {
32269         dd, esep := d.d, d.hh.hasElemSeparators()
32270         containerLen := dd.ReadMapStart()
32271         if canChange && v == nil {
32272                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
32273                 v = make(map[int32]uint, xlen)
32274                 changed = true
32275         }
32276         if containerLen == 0 {
32277                 dd.ReadMapEnd()
32278                 return v, changed
32279         }
32280         d.depthIncr()
32281         var mk int32
32282         var mv uint
32283         hasLen := containerLen > 0
32284         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32285                 if esep {
32286                         dd.ReadMapElemKey()
32287                 }
32288                 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32289                 if esep {
32290                         dd.ReadMapElemValue()
32291                 }
32292                 if dd.TryDecodeAsNil() {
32293                         if v == nil {
32294                         } else if d.h.DeleteOnNilMapValue {
32295                                 delete(v, mk)
32296                         } else {
32297                                 v[mk] = 0
32298                         }
32299                         continue
32300                 }
32301                 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
32302                 if v != nil {
32303                         v[mk] = mv
32304                 }
32305         }
32306         dd.ReadMapEnd()
32307         d.depthDecr()
32308         return v, changed
32309 }
32310
32311 func (d *Decoder) fastpathDecMapInt32Uint8R(f *codecFnInfo, rv reflect.Value) {
32312         if rv.Kind() == reflect.Ptr {
32313                 vp := rv2i(rv).(*map[int32]uint8)
32314                 v, changed := fastpathTV.DecMapInt32Uint8V(*vp, true, d)
32315                 if changed {
32316                         *vp = v
32317                 }
32318         } else {
32319                 fastpathTV.DecMapInt32Uint8V(rv2i(rv).(map[int32]uint8), false, d)
32320         }
32321 }
32322 func (f fastpathT) DecMapInt32Uint8X(vp *map[int32]uint8, d *Decoder) {
32323         v, changed := f.DecMapInt32Uint8V(*vp, true, d)
32324         if changed {
32325                 *vp = v
32326         }
32327 }
32328 func (_ fastpathT) DecMapInt32Uint8V(v map[int32]uint8, canChange bool,
32329         d *Decoder) (_ map[int32]uint8, changed bool) {
32330         dd, esep := d.d, d.hh.hasElemSeparators()
32331         containerLen := dd.ReadMapStart()
32332         if canChange && v == nil {
32333                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
32334                 v = make(map[int32]uint8, xlen)
32335                 changed = true
32336         }
32337         if containerLen == 0 {
32338                 dd.ReadMapEnd()
32339                 return v, changed
32340         }
32341         d.depthIncr()
32342         var mk int32
32343         var mv uint8
32344         hasLen := containerLen > 0
32345         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32346                 if esep {
32347                         dd.ReadMapElemKey()
32348                 }
32349                 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32350                 if esep {
32351                         dd.ReadMapElemValue()
32352                 }
32353                 if dd.TryDecodeAsNil() {
32354                         if v == nil {
32355                         } else if d.h.DeleteOnNilMapValue {
32356                                 delete(v, mk)
32357                         } else {
32358                                 v[mk] = 0
32359                         }
32360                         continue
32361                 }
32362                 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
32363                 if v != nil {
32364                         v[mk] = mv
32365                 }
32366         }
32367         dd.ReadMapEnd()
32368         d.depthDecr()
32369         return v, changed
32370 }
32371
32372 func (d *Decoder) fastpathDecMapInt32Uint16R(f *codecFnInfo, rv reflect.Value) {
32373         if rv.Kind() == reflect.Ptr {
32374                 vp := rv2i(rv).(*map[int32]uint16)
32375                 v, changed := fastpathTV.DecMapInt32Uint16V(*vp, true, d)
32376                 if changed {
32377                         *vp = v
32378                 }
32379         } else {
32380                 fastpathTV.DecMapInt32Uint16V(rv2i(rv).(map[int32]uint16), false, d)
32381         }
32382 }
32383 func (f fastpathT) DecMapInt32Uint16X(vp *map[int32]uint16, d *Decoder) {
32384         v, changed := f.DecMapInt32Uint16V(*vp, true, d)
32385         if changed {
32386                 *vp = v
32387         }
32388 }
32389 func (_ fastpathT) DecMapInt32Uint16V(v map[int32]uint16, canChange bool,
32390         d *Decoder) (_ map[int32]uint16, changed bool) {
32391         dd, esep := d.d, d.hh.hasElemSeparators()
32392         containerLen := dd.ReadMapStart()
32393         if canChange && v == nil {
32394                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
32395                 v = make(map[int32]uint16, xlen)
32396                 changed = true
32397         }
32398         if containerLen == 0 {
32399                 dd.ReadMapEnd()
32400                 return v, changed
32401         }
32402         d.depthIncr()
32403         var mk int32
32404         var mv uint16
32405         hasLen := containerLen > 0
32406         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32407                 if esep {
32408                         dd.ReadMapElemKey()
32409                 }
32410                 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32411                 if esep {
32412                         dd.ReadMapElemValue()
32413                 }
32414                 if dd.TryDecodeAsNil() {
32415                         if v == nil {
32416                         } else if d.h.DeleteOnNilMapValue {
32417                                 delete(v, mk)
32418                         } else {
32419                                 v[mk] = 0
32420                         }
32421                         continue
32422                 }
32423                 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
32424                 if v != nil {
32425                         v[mk] = mv
32426                 }
32427         }
32428         dd.ReadMapEnd()
32429         d.depthDecr()
32430         return v, changed
32431 }
32432
32433 func (d *Decoder) fastpathDecMapInt32Uint32R(f *codecFnInfo, rv reflect.Value) {
32434         if rv.Kind() == reflect.Ptr {
32435                 vp := rv2i(rv).(*map[int32]uint32)
32436                 v, changed := fastpathTV.DecMapInt32Uint32V(*vp, true, d)
32437                 if changed {
32438                         *vp = v
32439                 }
32440         } else {
32441                 fastpathTV.DecMapInt32Uint32V(rv2i(rv).(map[int32]uint32), false, d)
32442         }
32443 }
32444 func (f fastpathT) DecMapInt32Uint32X(vp *map[int32]uint32, d *Decoder) {
32445         v, changed := f.DecMapInt32Uint32V(*vp, true, d)
32446         if changed {
32447                 *vp = v
32448         }
32449 }
32450 func (_ fastpathT) DecMapInt32Uint32V(v map[int32]uint32, canChange bool,
32451         d *Decoder) (_ map[int32]uint32, changed bool) {
32452         dd, esep := d.d, d.hh.hasElemSeparators()
32453         containerLen := dd.ReadMapStart()
32454         if canChange && v == nil {
32455                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
32456                 v = make(map[int32]uint32, xlen)
32457                 changed = true
32458         }
32459         if containerLen == 0 {
32460                 dd.ReadMapEnd()
32461                 return v, changed
32462         }
32463         d.depthIncr()
32464         var mk int32
32465         var mv uint32
32466         hasLen := containerLen > 0
32467         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32468                 if esep {
32469                         dd.ReadMapElemKey()
32470                 }
32471                 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32472                 if esep {
32473                         dd.ReadMapElemValue()
32474                 }
32475                 if dd.TryDecodeAsNil() {
32476                         if v == nil {
32477                         } else if d.h.DeleteOnNilMapValue {
32478                                 delete(v, mk)
32479                         } else {
32480                                 v[mk] = 0
32481                         }
32482                         continue
32483                 }
32484                 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
32485                 if v != nil {
32486                         v[mk] = mv
32487                 }
32488         }
32489         dd.ReadMapEnd()
32490         d.depthDecr()
32491         return v, changed
32492 }
32493
32494 func (d *Decoder) fastpathDecMapInt32Uint64R(f *codecFnInfo, rv reflect.Value) {
32495         if rv.Kind() == reflect.Ptr {
32496                 vp := rv2i(rv).(*map[int32]uint64)
32497                 v, changed := fastpathTV.DecMapInt32Uint64V(*vp, true, d)
32498                 if changed {
32499                         *vp = v
32500                 }
32501         } else {
32502                 fastpathTV.DecMapInt32Uint64V(rv2i(rv).(map[int32]uint64), false, d)
32503         }
32504 }
32505 func (f fastpathT) DecMapInt32Uint64X(vp *map[int32]uint64, d *Decoder) {
32506         v, changed := f.DecMapInt32Uint64V(*vp, true, d)
32507         if changed {
32508                 *vp = v
32509         }
32510 }
32511 func (_ fastpathT) DecMapInt32Uint64V(v map[int32]uint64, canChange bool,
32512         d *Decoder) (_ map[int32]uint64, changed bool) {
32513         dd, esep := d.d, d.hh.hasElemSeparators()
32514         containerLen := dd.ReadMapStart()
32515         if canChange && v == nil {
32516                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
32517                 v = make(map[int32]uint64, xlen)
32518                 changed = true
32519         }
32520         if containerLen == 0 {
32521                 dd.ReadMapEnd()
32522                 return v, changed
32523         }
32524         d.depthIncr()
32525         var mk int32
32526         var mv uint64
32527         hasLen := containerLen > 0
32528         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32529                 if esep {
32530                         dd.ReadMapElemKey()
32531                 }
32532                 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32533                 if esep {
32534                         dd.ReadMapElemValue()
32535                 }
32536                 if dd.TryDecodeAsNil() {
32537                         if v == nil {
32538                         } else if d.h.DeleteOnNilMapValue {
32539                                 delete(v, mk)
32540                         } else {
32541                                 v[mk] = 0
32542                         }
32543                         continue
32544                 }
32545                 mv = dd.DecodeUint64()
32546                 if v != nil {
32547                         v[mk] = mv
32548                 }
32549         }
32550         dd.ReadMapEnd()
32551         d.depthDecr()
32552         return v, changed
32553 }
32554
32555 func (d *Decoder) fastpathDecMapInt32UintptrR(f *codecFnInfo, rv reflect.Value) {
32556         if rv.Kind() == reflect.Ptr {
32557                 vp := rv2i(rv).(*map[int32]uintptr)
32558                 v, changed := fastpathTV.DecMapInt32UintptrV(*vp, true, d)
32559                 if changed {
32560                         *vp = v
32561                 }
32562         } else {
32563                 fastpathTV.DecMapInt32UintptrV(rv2i(rv).(map[int32]uintptr), false, d)
32564         }
32565 }
32566 func (f fastpathT) DecMapInt32UintptrX(vp *map[int32]uintptr, d *Decoder) {
32567         v, changed := f.DecMapInt32UintptrV(*vp, true, d)
32568         if changed {
32569                 *vp = v
32570         }
32571 }
32572 func (_ fastpathT) DecMapInt32UintptrV(v map[int32]uintptr, canChange bool,
32573         d *Decoder) (_ map[int32]uintptr, changed bool) {
32574         dd, esep := d.d, d.hh.hasElemSeparators()
32575         containerLen := dd.ReadMapStart()
32576         if canChange && v == nil {
32577                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
32578                 v = make(map[int32]uintptr, xlen)
32579                 changed = true
32580         }
32581         if containerLen == 0 {
32582                 dd.ReadMapEnd()
32583                 return v, changed
32584         }
32585         d.depthIncr()
32586         var mk int32
32587         var mv uintptr
32588         hasLen := containerLen > 0
32589         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32590                 if esep {
32591                         dd.ReadMapElemKey()
32592                 }
32593                 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32594                 if esep {
32595                         dd.ReadMapElemValue()
32596                 }
32597                 if dd.TryDecodeAsNil() {
32598                         if v == nil {
32599                         } else if d.h.DeleteOnNilMapValue {
32600                                 delete(v, mk)
32601                         } else {
32602                                 v[mk] = 0
32603                         }
32604                         continue
32605                 }
32606                 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
32607                 if v != nil {
32608                         v[mk] = mv
32609                 }
32610         }
32611         dd.ReadMapEnd()
32612         d.depthDecr()
32613         return v, changed
32614 }
32615
32616 func (d *Decoder) fastpathDecMapInt32IntR(f *codecFnInfo, rv reflect.Value) {
32617         if rv.Kind() == reflect.Ptr {
32618                 vp := rv2i(rv).(*map[int32]int)
32619                 v, changed := fastpathTV.DecMapInt32IntV(*vp, true, d)
32620                 if changed {
32621                         *vp = v
32622                 }
32623         } else {
32624                 fastpathTV.DecMapInt32IntV(rv2i(rv).(map[int32]int), false, d)
32625         }
32626 }
32627 func (f fastpathT) DecMapInt32IntX(vp *map[int32]int, d *Decoder) {
32628         v, changed := f.DecMapInt32IntV(*vp, true, d)
32629         if changed {
32630                 *vp = v
32631         }
32632 }
32633 func (_ fastpathT) DecMapInt32IntV(v map[int32]int, canChange bool,
32634         d *Decoder) (_ map[int32]int, changed bool) {
32635         dd, esep := d.d, d.hh.hasElemSeparators()
32636         containerLen := dd.ReadMapStart()
32637         if canChange && v == nil {
32638                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
32639                 v = make(map[int32]int, xlen)
32640                 changed = true
32641         }
32642         if containerLen == 0 {
32643                 dd.ReadMapEnd()
32644                 return v, changed
32645         }
32646         d.depthIncr()
32647         var mk int32
32648         var mv int
32649         hasLen := containerLen > 0
32650         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32651                 if esep {
32652                         dd.ReadMapElemKey()
32653                 }
32654                 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32655                 if esep {
32656                         dd.ReadMapElemValue()
32657                 }
32658                 if dd.TryDecodeAsNil() {
32659                         if v == nil {
32660                         } else if d.h.DeleteOnNilMapValue {
32661                                 delete(v, mk)
32662                         } else {
32663                                 v[mk] = 0
32664                         }
32665                         continue
32666                 }
32667                 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
32668                 if v != nil {
32669                         v[mk] = mv
32670                 }
32671         }
32672         dd.ReadMapEnd()
32673         d.depthDecr()
32674         return v, changed
32675 }
32676
32677 func (d *Decoder) fastpathDecMapInt32Int8R(f *codecFnInfo, rv reflect.Value) {
32678         if rv.Kind() == reflect.Ptr {
32679                 vp := rv2i(rv).(*map[int32]int8)
32680                 v, changed := fastpathTV.DecMapInt32Int8V(*vp, true, d)
32681                 if changed {
32682                         *vp = v
32683                 }
32684         } else {
32685                 fastpathTV.DecMapInt32Int8V(rv2i(rv).(map[int32]int8), false, d)
32686         }
32687 }
32688 func (f fastpathT) DecMapInt32Int8X(vp *map[int32]int8, d *Decoder) {
32689         v, changed := f.DecMapInt32Int8V(*vp, true, d)
32690         if changed {
32691                 *vp = v
32692         }
32693 }
32694 func (_ fastpathT) DecMapInt32Int8V(v map[int32]int8, canChange bool,
32695         d *Decoder) (_ map[int32]int8, changed bool) {
32696         dd, esep := d.d, d.hh.hasElemSeparators()
32697         containerLen := dd.ReadMapStart()
32698         if canChange && v == nil {
32699                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
32700                 v = make(map[int32]int8, xlen)
32701                 changed = true
32702         }
32703         if containerLen == 0 {
32704                 dd.ReadMapEnd()
32705                 return v, changed
32706         }
32707         d.depthIncr()
32708         var mk int32
32709         var mv int8
32710         hasLen := containerLen > 0
32711         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32712                 if esep {
32713                         dd.ReadMapElemKey()
32714                 }
32715                 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32716                 if esep {
32717                         dd.ReadMapElemValue()
32718                 }
32719                 if dd.TryDecodeAsNil() {
32720                         if v == nil {
32721                         } else if d.h.DeleteOnNilMapValue {
32722                                 delete(v, mk)
32723                         } else {
32724                                 v[mk] = 0
32725                         }
32726                         continue
32727                 }
32728                 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
32729                 if v != nil {
32730                         v[mk] = mv
32731                 }
32732         }
32733         dd.ReadMapEnd()
32734         d.depthDecr()
32735         return v, changed
32736 }
32737
32738 func (d *Decoder) fastpathDecMapInt32Int16R(f *codecFnInfo, rv reflect.Value) {
32739         if rv.Kind() == reflect.Ptr {
32740                 vp := rv2i(rv).(*map[int32]int16)
32741                 v, changed := fastpathTV.DecMapInt32Int16V(*vp, true, d)
32742                 if changed {
32743                         *vp = v
32744                 }
32745         } else {
32746                 fastpathTV.DecMapInt32Int16V(rv2i(rv).(map[int32]int16), false, d)
32747         }
32748 }
32749 func (f fastpathT) DecMapInt32Int16X(vp *map[int32]int16, d *Decoder) {
32750         v, changed := f.DecMapInt32Int16V(*vp, true, d)
32751         if changed {
32752                 *vp = v
32753         }
32754 }
32755 func (_ fastpathT) DecMapInt32Int16V(v map[int32]int16, canChange bool,
32756         d *Decoder) (_ map[int32]int16, changed bool) {
32757         dd, esep := d.d, d.hh.hasElemSeparators()
32758         containerLen := dd.ReadMapStart()
32759         if canChange && v == nil {
32760                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
32761                 v = make(map[int32]int16, xlen)
32762                 changed = true
32763         }
32764         if containerLen == 0 {
32765                 dd.ReadMapEnd()
32766                 return v, changed
32767         }
32768         d.depthIncr()
32769         var mk int32
32770         var mv int16
32771         hasLen := containerLen > 0
32772         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32773                 if esep {
32774                         dd.ReadMapElemKey()
32775                 }
32776                 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32777                 if esep {
32778                         dd.ReadMapElemValue()
32779                 }
32780                 if dd.TryDecodeAsNil() {
32781                         if v == nil {
32782                         } else if d.h.DeleteOnNilMapValue {
32783                                 delete(v, mk)
32784                         } else {
32785                                 v[mk] = 0
32786                         }
32787                         continue
32788                 }
32789                 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
32790                 if v != nil {
32791                         v[mk] = mv
32792                 }
32793         }
32794         dd.ReadMapEnd()
32795         d.depthDecr()
32796         return v, changed
32797 }
32798
32799 func (d *Decoder) fastpathDecMapInt32Int32R(f *codecFnInfo, rv reflect.Value) {
32800         if rv.Kind() == reflect.Ptr {
32801                 vp := rv2i(rv).(*map[int32]int32)
32802                 v, changed := fastpathTV.DecMapInt32Int32V(*vp, true, d)
32803                 if changed {
32804                         *vp = v
32805                 }
32806         } else {
32807                 fastpathTV.DecMapInt32Int32V(rv2i(rv).(map[int32]int32), false, d)
32808         }
32809 }
32810 func (f fastpathT) DecMapInt32Int32X(vp *map[int32]int32, d *Decoder) {
32811         v, changed := f.DecMapInt32Int32V(*vp, true, d)
32812         if changed {
32813                 *vp = v
32814         }
32815 }
32816 func (_ fastpathT) DecMapInt32Int32V(v map[int32]int32, canChange bool,
32817         d *Decoder) (_ map[int32]int32, changed bool) {
32818         dd, esep := d.d, d.hh.hasElemSeparators()
32819         containerLen := dd.ReadMapStart()
32820         if canChange && v == nil {
32821                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
32822                 v = make(map[int32]int32, xlen)
32823                 changed = true
32824         }
32825         if containerLen == 0 {
32826                 dd.ReadMapEnd()
32827                 return v, changed
32828         }
32829         d.depthIncr()
32830         var mk int32
32831         var mv int32
32832         hasLen := containerLen > 0
32833         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32834                 if esep {
32835                         dd.ReadMapElemKey()
32836                 }
32837                 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32838                 if esep {
32839                         dd.ReadMapElemValue()
32840                 }
32841                 if dd.TryDecodeAsNil() {
32842                         if v == nil {
32843                         } else if d.h.DeleteOnNilMapValue {
32844                                 delete(v, mk)
32845                         } else {
32846                                 v[mk] = 0
32847                         }
32848                         continue
32849                 }
32850                 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32851                 if v != nil {
32852                         v[mk] = mv
32853                 }
32854         }
32855         dd.ReadMapEnd()
32856         d.depthDecr()
32857         return v, changed
32858 }
32859
32860 func (d *Decoder) fastpathDecMapInt32Int64R(f *codecFnInfo, rv reflect.Value) {
32861         if rv.Kind() == reflect.Ptr {
32862                 vp := rv2i(rv).(*map[int32]int64)
32863                 v, changed := fastpathTV.DecMapInt32Int64V(*vp, true, d)
32864                 if changed {
32865                         *vp = v
32866                 }
32867         } else {
32868                 fastpathTV.DecMapInt32Int64V(rv2i(rv).(map[int32]int64), false, d)
32869         }
32870 }
32871 func (f fastpathT) DecMapInt32Int64X(vp *map[int32]int64, d *Decoder) {
32872         v, changed := f.DecMapInt32Int64V(*vp, true, d)
32873         if changed {
32874                 *vp = v
32875         }
32876 }
32877 func (_ fastpathT) DecMapInt32Int64V(v map[int32]int64, canChange bool,
32878         d *Decoder) (_ map[int32]int64, changed bool) {
32879         dd, esep := d.d, d.hh.hasElemSeparators()
32880         containerLen := dd.ReadMapStart()
32881         if canChange && v == nil {
32882                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
32883                 v = make(map[int32]int64, xlen)
32884                 changed = true
32885         }
32886         if containerLen == 0 {
32887                 dd.ReadMapEnd()
32888                 return v, changed
32889         }
32890         d.depthIncr()
32891         var mk int32
32892         var mv int64
32893         hasLen := containerLen > 0
32894         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32895                 if esep {
32896                         dd.ReadMapElemKey()
32897                 }
32898                 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32899                 if esep {
32900                         dd.ReadMapElemValue()
32901                 }
32902                 if dd.TryDecodeAsNil() {
32903                         if v == nil {
32904                         } else if d.h.DeleteOnNilMapValue {
32905                                 delete(v, mk)
32906                         } else {
32907                                 v[mk] = 0
32908                         }
32909                         continue
32910                 }
32911                 mv = dd.DecodeInt64()
32912                 if v != nil {
32913                         v[mk] = mv
32914                 }
32915         }
32916         dd.ReadMapEnd()
32917         d.depthDecr()
32918         return v, changed
32919 }
32920
32921 func (d *Decoder) fastpathDecMapInt32Float32R(f *codecFnInfo, rv reflect.Value) {
32922         if rv.Kind() == reflect.Ptr {
32923                 vp := rv2i(rv).(*map[int32]float32)
32924                 v, changed := fastpathTV.DecMapInt32Float32V(*vp, true, d)
32925                 if changed {
32926                         *vp = v
32927                 }
32928         } else {
32929                 fastpathTV.DecMapInt32Float32V(rv2i(rv).(map[int32]float32), false, d)
32930         }
32931 }
32932 func (f fastpathT) DecMapInt32Float32X(vp *map[int32]float32, d *Decoder) {
32933         v, changed := f.DecMapInt32Float32V(*vp, true, d)
32934         if changed {
32935                 *vp = v
32936         }
32937 }
32938 func (_ fastpathT) DecMapInt32Float32V(v map[int32]float32, canChange bool,
32939         d *Decoder) (_ map[int32]float32, changed bool) {
32940         dd, esep := d.d, d.hh.hasElemSeparators()
32941         containerLen := dd.ReadMapStart()
32942         if canChange && v == nil {
32943                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
32944                 v = make(map[int32]float32, xlen)
32945                 changed = true
32946         }
32947         if containerLen == 0 {
32948                 dd.ReadMapEnd()
32949                 return v, changed
32950         }
32951         d.depthIncr()
32952         var mk int32
32953         var mv float32
32954         hasLen := containerLen > 0
32955         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32956                 if esep {
32957                         dd.ReadMapElemKey()
32958                 }
32959                 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32960                 if esep {
32961                         dd.ReadMapElemValue()
32962                 }
32963                 if dd.TryDecodeAsNil() {
32964                         if v == nil {
32965                         } else if d.h.DeleteOnNilMapValue {
32966                                 delete(v, mk)
32967                         } else {
32968                                 v[mk] = 0
32969                         }
32970                         continue
32971                 }
32972                 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
32973                 if v != nil {
32974                         v[mk] = mv
32975                 }
32976         }
32977         dd.ReadMapEnd()
32978         d.depthDecr()
32979         return v, changed
32980 }
32981
32982 func (d *Decoder) fastpathDecMapInt32Float64R(f *codecFnInfo, rv reflect.Value) {
32983         if rv.Kind() == reflect.Ptr {
32984                 vp := rv2i(rv).(*map[int32]float64)
32985                 v, changed := fastpathTV.DecMapInt32Float64V(*vp, true, d)
32986                 if changed {
32987                         *vp = v
32988                 }
32989         } else {
32990                 fastpathTV.DecMapInt32Float64V(rv2i(rv).(map[int32]float64), false, d)
32991         }
32992 }
32993 func (f fastpathT) DecMapInt32Float64X(vp *map[int32]float64, d *Decoder) {
32994         v, changed := f.DecMapInt32Float64V(*vp, true, d)
32995         if changed {
32996                 *vp = v
32997         }
32998 }
32999 func (_ fastpathT) DecMapInt32Float64V(v map[int32]float64, canChange bool,
33000         d *Decoder) (_ map[int32]float64, changed bool) {
33001         dd, esep := d.d, d.hh.hasElemSeparators()
33002         containerLen := dd.ReadMapStart()
33003         if canChange && v == nil {
33004                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
33005                 v = make(map[int32]float64, xlen)
33006                 changed = true
33007         }
33008         if containerLen == 0 {
33009                 dd.ReadMapEnd()
33010                 return v, changed
33011         }
33012         d.depthIncr()
33013         var mk int32
33014         var mv float64
33015         hasLen := containerLen > 0
33016         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33017                 if esep {
33018                         dd.ReadMapElemKey()
33019                 }
33020                 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
33021                 if esep {
33022                         dd.ReadMapElemValue()
33023                 }
33024                 if dd.TryDecodeAsNil() {
33025                         if v == nil {
33026                         } else if d.h.DeleteOnNilMapValue {
33027                                 delete(v, mk)
33028                         } else {
33029                                 v[mk] = 0
33030                         }
33031                         continue
33032                 }
33033                 mv = dd.DecodeFloat64()
33034                 if v != nil {
33035                         v[mk] = mv
33036                 }
33037         }
33038         dd.ReadMapEnd()
33039         d.depthDecr()
33040         return v, changed
33041 }
33042
33043 func (d *Decoder) fastpathDecMapInt32BoolR(f *codecFnInfo, rv reflect.Value) {
33044         if rv.Kind() == reflect.Ptr {
33045                 vp := rv2i(rv).(*map[int32]bool)
33046                 v, changed := fastpathTV.DecMapInt32BoolV(*vp, true, d)
33047                 if changed {
33048                         *vp = v
33049                 }
33050         } else {
33051                 fastpathTV.DecMapInt32BoolV(rv2i(rv).(map[int32]bool), false, d)
33052         }
33053 }
33054 func (f fastpathT) DecMapInt32BoolX(vp *map[int32]bool, d *Decoder) {
33055         v, changed := f.DecMapInt32BoolV(*vp, true, d)
33056         if changed {
33057                 *vp = v
33058         }
33059 }
33060 func (_ fastpathT) DecMapInt32BoolV(v map[int32]bool, canChange bool,
33061         d *Decoder) (_ map[int32]bool, changed bool) {
33062         dd, esep := d.d, d.hh.hasElemSeparators()
33063         containerLen := dd.ReadMapStart()
33064         if canChange && v == nil {
33065                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
33066                 v = make(map[int32]bool, xlen)
33067                 changed = true
33068         }
33069         if containerLen == 0 {
33070                 dd.ReadMapEnd()
33071                 return v, changed
33072         }
33073         d.depthIncr()
33074         var mk int32
33075         var mv bool
33076         hasLen := containerLen > 0
33077         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33078                 if esep {
33079                         dd.ReadMapElemKey()
33080                 }
33081                 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
33082                 if esep {
33083                         dd.ReadMapElemValue()
33084                 }
33085                 if dd.TryDecodeAsNil() {
33086                         if v == nil {
33087                         } else if d.h.DeleteOnNilMapValue {
33088                                 delete(v, mk)
33089                         } else {
33090                                 v[mk] = false
33091                         }
33092                         continue
33093                 }
33094                 mv = dd.DecodeBool()
33095                 if v != nil {
33096                         v[mk] = mv
33097                 }
33098         }
33099         dd.ReadMapEnd()
33100         d.depthDecr()
33101         return v, changed
33102 }
33103
33104 func (d *Decoder) fastpathDecMapInt64IntfR(f *codecFnInfo, rv reflect.Value) {
33105         if rv.Kind() == reflect.Ptr {
33106                 vp := rv2i(rv).(*map[int64]interface{})
33107                 v, changed := fastpathTV.DecMapInt64IntfV(*vp, true, d)
33108                 if changed {
33109                         *vp = v
33110                 }
33111         } else {
33112                 fastpathTV.DecMapInt64IntfV(rv2i(rv).(map[int64]interface{}), false, d)
33113         }
33114 }
33115 func (f fastpathT) DecMapInt64IntfX(vp *map[int64]interface{}, d *Decoder) {
33116         v, changed := f.DecMapInt64IntfV(*vp, true, d)
33117         if changed {
33118                 *vp = v
33119         }
33120 }
33121 func (_ fastpathT) DecMapInt64IntfV(v map[int64]interface{}, canChange bool,
33122         d *Decoder) (_ map[int64]interface{}, changed bool) {
33123         dd, esep := d.d, d.hh.hasElemSeparators()
33124         containerLen := dd.ReadMapStart()
33125         if canChange && v == nil {
33126                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
33127                 v = make(map[int64]interface{}, xlen)
33128                 changed = true
33129         }
33130         if containerLen == 0 {
33131                 dd.ReadMapEnd()
33132                 return v, changed
33133         }
33134         d.depthIncr()
33135         mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
33136         var mk int64
33137         var mv interface{}
33138         hasLen := containerLen > 0
33139         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33140                 if esep {
33141                         dd.ReadMapElemKey()
33142                 }
33143                 mk = dd.DecodeInt64()
33144                 if esep {
33145                         dd.ReadMapElemValue()
33146                 }
33147                 if dd.TryDecodeAsNil() {
33148                         if v == nil {
33149                         } else if d.h.DeleteOnNilMapValue {
33150                                 delete(v, mk)
33151                         } else {
33152                                 v[mk] = nil
33153                         }
33154                         continue
33155                 }
33156                 if mapGet {
33157                         mv = v[mk]
33158                 } else {
33159                         mv = nil
33160                 }
33161                 d.decode(&mv)
33162                 if v != nil {
33163                         v[mk] = mv
33164                 }
33165         }
33166         dd.ReadMapEnd()
33167         d.depthDecr()
33168         return v, changed
33169 }
33170
33171 func (d *Decoder) fastpathDecMapInt64StringR(f *codecFnInfo, rv reflect.Value) {
33172         if rv.Kind() == reflect.Ptr {
33173                 vp := rv2i(rv).(*map[int64]string)
33174                 v, changed := fastpathTV.DecMapInt64StringV(*vp, true, d)
33175                 if changed {
33176                         *vp = v
33177                 }
33178         } else {
33179                 fastpathTV.DecMapInt64StringV(rv2i(rv).(map[int64]string), false, d)
33180         }
33181 }
33182 func (f fastpathT) DecMapInt64StringX(vp *map[int64]string, d *Decoder) {
33183         v, changed := f.DecMapInt64StringV(*vp, true, d)
33184         if changed {
33185                 *vp = v
33186         }
33187 }
33188 func (_ fastpathT) DecMapInt64StringV(v map[int64]string, canChange bool,
33189         d *Decoder) (_ map[int64]string, changed bool) {
33190         dd, esep := d.d, d.hh.hasElemSeparators()
33191         containerLen := dd.ReadMapStart()
33192         if canChange && v == nil {
33193                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
33194                 v = make(map[int64]string, xlen)
33195                 changed = true
33196         }
33197         if containerLen == 0 {
33198                 dd.ReadMapEnd()
33199                 return v, changed
33200         }
33201         d.depthIncr()
33202         var mk int64
33203         var mv string
33204         hasLen := containerLen > 0
33205         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33206                 if esep {
33207                         dd.ReadMapElemKey()
33208                 }
33209                 mk = dd.DecodeInt64()
33210                 if esep {
33211                         dd.ReadMapElemValue()
33212                 }
33213                 if dd.TryDecodeAsNil() {
33214                         if v == nil {
33215                         } else if d.h.DeleteOnNilMapValue {
33216                                 delete(v, mk)
33217                         } else {
33218                                 v[mk] = ""
33219                         }
33220                         continue
33221                 }
33222                 mv = dd.DecodeString()
33223                 if v != nil {
33224                         v[mk] = mv
33225                 }
33226         }
33227         dd.ReadMapEnd()
33228         d.depthDecr()
33229         return v, changed
33230 }
33231
33232 func (d *Decoder) fastpathDecMapInt64UintR(f *codecFnInfo, rv reflect.Value) {
33233         if rv.Kind() == reflect.Ptr {
33234                 vp := rv2i(rv).(*map[int64]uint)
33235                 v, changed := fastpathTV.DecMapInt64UintV(*vp, true, d)
33236                 if changed {
33237                         *vp = v
33238                 }
33239         } else {
33240                 fastpathTV.DecMapInt64UintV(rv2i(rv).(map[int64]uint), false, d)
33241         }
33242 }
33243 func (f fastpathT) DecMapInt64UintX(vp *map[int64]uint, d *Decoder) {
33244         v, changed := f.DecMapInt64UintV(*vp, true, d)
33245         if changed {
33246                 *vp = v
33247         }
33248 }
33249 func (_ fastpathT) DecMapInt64UintV(v map[int64]uint, canChange bool,
33250         d *Decoder) (_ map[int64]uint, changed bool) {
33251         dd, esep := d.d, d.hh.hasElemSeparators()
33252         containerLen := dd.ReadMapStart()
33253         if canChange && v == nil {
33254                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
33255                 v = make(map[int64]uint, xlen)
33256                 changed = true
33257         }
33258         if containerLen == 0 {
33259                 dd.ReadMapEnd()
33260                 return v, changed
33261         }
33262         d.depthIncr()
33263         var mk int64
33264         var mv uint
33265         hasLen := containerLen > 0
33266         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33267                 if esep {
33268                         dd.ReadMapElemKey()
33269                 }
33270                 mk = dd.DecodeInt64()
33271                 if esep {
33272                         dd.ReadMapElemValue()
33273                 }
33274                 if dd.TryDecodeAsNil() {
33275                         if v == nil {
33276                         } else if d.h.DeleteOnNilMapValue {
33277                                 delete(v, mk)
33278                         } else {
33279                                 v[mk] = 0
33280                         }
33281                         continue
33282                 }
33283                 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
33284                 if v != nil {
33285                         v[mk] = mv
33286                 }
33287         }
33288         dd.ReadMapEnd()
33289         d.depthDecr()
33290         return v, changed
33291 }
33292
33293 func (d *Decoder) fastpathDecMapInt64Uint8R(f *codecFnInfo, rv reflect.Value) {
33294         if rv.Kind() == reflect.Ptr {
33295                 vp := rv2i(rv).(*map[int64]uint8)
33296                 v, changed := fastpathTV.DecMapInt64Uint8V(*vp, true, d)
33297                 if changed {
33298                         *vp = v
33299                 }
33300         } else {
33301                 fastpathTV.DecMapInt64Uint8V(rv2i(rv).(map[int64]uint8), false, d)
33302         }
33303 }
33304 func (f fastpathT) DecMapInt64Uint8X(vp *map[int64]uint8, d *Decoder) {
33305         v, changed := f.DecMapInt64Uint8V(*vp, true, d)
33306         if changed {
33307                 *vp = v
33308         }
33309 }
33310 func (_ fastpathT) DecMapInt64Uint8V(v map[int64]uint8, canChange bool,
33311         d *Decoder) (_ map[int64]uint8, changed bool) {
33312         dd, esep := d.d, d.hh.hasElemSeparators()
33313         containerLen := dd.ReadMapStart()
33314         if canChange && v == nil {
33315                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
33316                 v = make(map[int64]uint8, xlen)
33317                 changed = true
33318         }
33319         if containerLen == 0 {
33320                 dd.ReadMapEnd()
33321                 return v, changed
33322         }
33323         d.depthIncr()
33324         var mk int64
33325         var mv uint8
33326         hasLen := containerLen > 0
33327         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33328                 if esep {
33329                         dd.ReadMapElemKey()
33330                 }
33331                 mk = dd.DecodeInt64()
33332                 if esep {
33333                         dd.ReadMapElemValue()
33334                 }
33335                 if dd.TryDecodeAsNil() {
33336                         if v == nil {
33337                         } else if d.h.DeleteOnNilMapValue {
33338                                 delete(v, mk)
33339                         } else {
33340                                 v[mk] = 0
33341                         }
33342                         continue
33343                 }
33344                 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
33345                 if v != nil {
33346                         v[mk] = mv
33347                 }
33348         }
33349         dd.ReadMapEnd()
33350         d.depthDecr()
33351         return v, changed
33352 }
33353
33354 func (d *Decoder) fastpathDecMapInt64Uint16R(f *codecFnInfo, rv reflect.Value) {
33355         if rv.Kind() == reflect.Ptr {
33356                 vp := rv2i(rv).(*map[int64]uint16)
33357                 v, changed := fastpathTV.DecMapInt64Uint16V(*vp, true, d)
33358                 if changed {
33359                         *vp = v
33360                 }
33361         } else {
33362                 fastpathTV.DecMapInt64Uint16V(rv2i(rv).(map[int64]uint16), false, d)
33363         }
33364 }
33365 func (f fastpathT) DecMapInt64Uint16X(vp *map[int64]uint16, d *Decoder) {
33366         v, changed := f.DecMapInt64Uint16V(*vp, true, d)
33367         if changed {
33368                 *vp = v
33369         }
33370 }
33371 func (_ fastpathT) DecMapInt64Uint16V(v map[int64]uint16, canChange bool,
33372         d *Decoder) (_ map[int64]uint16, changed bool) {
33373         dd, esep := d.d, d.hh.hasElemSeparators()
33374         containerLen := dd.ReadMapStart()
33375         if canChange && v == nil {
33376                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
33377                 v = make(map[int64]uint16, xlen)
33378                 changed = true
33379         }
33380         if containerLen == 0 {
33381                 dd.ReadMapEnd()
33382                 return v, changed
33383         }
33384         d.depthIncr()
33385         var mk int64
33386         var mv uint16
33387         hasLen := containerLen > 0
33388         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33389                 if esep {
33390                         dd.ReadMapElemKey()
33391                 }
33392                 mk = dd.DecodeInt64()
33393                 if esep {
33394                         dd.ReadMapElemValue()
33395                 }
33396                 if dd.TryDecodeAsNil() {
33397                         if v == nil {
33398                         } else if d.h.DeleteOnNilMapValue {
33399                                 delete(v, mk)
33400                         } else {
33401                                 v[mk] = 0
33402                         }
33403                         continue
33404                 }
33405                 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
33406                 if v != nil {
33407                         v[mk] = mv
33408                 }
33409         }
33410         dd.ReadMapEnd()
33411         d.depthDecr()
33412         return v, changed
33413 }
33414
33415 func (d *Decoder) fastpathDecMapInt64Uint32R(f *codecFnInfo, rv reflect.Value) {
33416         if rv.Kind() == reflect.Ptr {
33417                 vp := rv2i(rv).(*map[int64]uint32)
33418                 v, changed := fastpathTV.DecMapInt64Uint32V(*vp, true, d)
33419                 if changed {
33420                         *vp = v
33421                 }
33422         } else {
33423                 fastpathTV.DecMapInt64Uint32V(rv2i(rv).(map[int64]uint32), false, d)
33424         }
33425 }
33426 func (f fastpathT) DecMapInt64Uint32X(vp *map[int64]uint32, d *Decoder) {
33427         v, changed := f.DecMapInt64Uint32V(*vp, true, d)
33428         if changed {
33429                 *vp = v
33430         }
33431 }
33432 func (_ fastpathT) DecMapInt64Uint32V(v map[int64]uint32, canChange bool,
33433         d *Decoder) (_ map[int64]uint32, changed bool) {
33434         dd, esep := d.d, d.hh.hasElemSeparators()
33435         containerLen := dd.ReadMapStart()
33436         if canChange && v == nil {
33437                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
33438                 v = make(map[int64]uint32, xlen)
33439                 changed = true
33440         }
33441         if containerLen == 0 {
33442                 dd.ReadMapEnd()
33443                 return v, changed
33444         }
33445         d.depthIncr()
33446         var mk int64
33447         var mv uint32
33448         hasLen := containerLen > 0
33449         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33450                 if esep {
33451                         dd.ReadMapElemKey()
33452                 }
33453                 mk = dd.DecodeInt64()
33454                 if esep {
33455                         dd.ReadMapElemValue()
33456                 }
33457                 if dd.TryDecodeAsNil() {
33458                         if v == nil {
33459                         } else if d.h.DeleteOnNilMapValue {
33460                                 delete(v, mk)
33461                         } else {
33462                                 v[mk] = 0
33463                         }
33464                         continue
33465                 }
33466                 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
33467                 if v != nil {
33468                         v[mk] = mv
33469                 }
33470         }
33471         dd.ReadMapEnd()
33472         d.depthDecr()
33473         return v, changed
33474 }
33475
33476 func (d *Decoder) fastpathDecMapInt64Uint64R(f *codecFnInfo, rv reflect.Value) {
33477         if rv.Kind() == reflect.Ptr {
33478                 vp := rv2i(rv).(*map[int64]uint64)
33479                 v, changed := fastpathTV.DecMapInt64Uint64V(*vp, true, d)
33480                 if changed {
33481                         *vp = v
33482                 }
33483         } else {
33484                 fastpathTV.DecMapInt64Uint64V(rv2i(rv).(map[int64]uint64), false, d)
33485         }
33486 }
33487 func (f fastpathT) DecMapInt64Uint64X(vp *map[int64]uint64, d *Decoder) {
33488         v, changed := f.DecMapInt64Uint64V(*vp, true, d)
33489         if changed {
33490                 *vp = v
33491         }
33492 }
33493 func (_ fastpathT) DecMapInt64Uint64V(v map[int64]uint64, canChange bool,
33494         d *Decoder) (_ map[int64]uint64, changed bool) {
33495         dd, esep := d.d, d.hh.hasElemSeparators()
33496         containerLen := dd.ReadMapStart()
33497         if canChange && v == nil {
33498                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
33499                 v = make(map[int64]uint64, xlen)
33500                 changed = true
33501         }
33502         if containerLen == 0 {
33503                 dd.ReadMapEnd()
33504                 return v, changed
33505         }
33506         d.depthIncr()
33507         var mk int64
33508         var mv uint64
33509         hasLen := containerLen > 0
33510         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33511                 if esep {
33512                         dd.ReadMapElemKey()
33513                 }
33514                 mk = dd.DecodeInt64()
33515                 if esep {
33516                         dd.ReadMapElemValue()
33517                 }
33518                 if dd.TryDecodeAsNil() {
33519                         if v == nil {
33520                         } else if d.h.DeleteOnNilMapValue {
33521                                 delete(v, mk)
33522                         } else {
33523                                 v[mk] = 0
33524                         }
33525                         continue
33526                 }
33527                 mv = dd.DecodeUint64()
33528                 if v != nil {
33529                         v[mk] = mv
33530                 }
33531         }
33532         dd.ReadMapEnd()
33533         d.depthDecr()
33534         return v, changed
33535 }
33536
33537 func (d *Decoder) fastpathDecMapInt64UintptrR(f *codecFnInfo, rv reflect.Value) {
33538         if rv.Kind() == reflect.Ptr {
33539                 vp := rv2i(rv).(*map[int64]uintptr)
33540                 v, changed := fastpathTV.DecMapInt64UintptrV(*vp, true, d)
33541                 if changed {
33542                         *vp = v
33543                 }
33544         } else {
33545                 fastpathTV.DecMapInt64UintptrV(rv2i(rv).(map[int64]uintptr), false, d)
33546         }
33547 }
33548 func (f fastpathT) DecMapInt64UintptrX(vp *map[int64]uintptr, d *Decoder) {
33549         v, changed := f.DecMapInt64UintptrV(*vp, true, d)
33550         if changed {
33551                 *vp = v
33552         }
33553 }
33554 func (_ fastpathT) DecMapInt64UintptrV(v map[int64]uintptr, canChange bool,
33555         d *Decoder) (_ map[int64]uintptr, changed bool) {
33556         dd, esep := d.d, d.hh.hasElemSeparators()
33557         containerLen := dd.ReadMapStart()
33558         if canChange && v == nil {
33559                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
33560                 v = make(map[int64]uintptr, xlen)
33561                 changed = true
33562         }
33563         if containerLen == 0 {
33564                 dd.ReadMapEnd()
33565                 return v, changed
33566         }
33567         d.depthIncr()
33568         var mk int64
33569         var mv uintptr
33570         hasLen := containerLen > 0
33571         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33572                 if esep {
33573                         dd.ReadMapElemKey()
33574                 }
33575                 mk = dd.DecodeInt64()
33576                 if esep {
33577                         dd.ReadMapElemValue()
33578                 }
33579                 if dd.TryDecodeAsNil() {
33580                         if v == nil {
33581                         } else if d.h.DeleteOnNilMapValue {
33582                                 delete(v, mk)
33583                         } else {
33584                                 v[mk] = 0
33585                         }
33586                         continue
33587                 }
33588                 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
33589                 if v != nil {
33590                         v[mk] = mv
33591                 }
33592         }
33593         dd.ReadMapEnd()
33594         d.depthDecr()
33595         return v, changed
33596 }
33597
33598 func (d *Decoder) fastpathDecMapInt64IntR(f *codecFnInfo, rv reflect.Value) {
33599         if rv.Kind() == reflect.Ptr {
33600                 vp := rv2i(rv).(*map[int64]int)
33601                 v, changed := fastpathTV.DecMapInt64IntV(*vp, true, d)
33602                 if changed {
33603                         *vp = v
33604                 }
33605         } else {
33606                 fastpathTV.DecMapInt64IntV(rv2i(rv).(map[int64]int), false, d)
33607         }
33608 }
33609 func (f fastpathT) DecMapInt64IntX(vp *map[int64]int, d *Decoder) {
33610         v, changed := f.DecMapInt64IntV(*vp, true, d)
33611         if changed {
33612                 *vp = v
33613         }
33614 }
33615 func (_ fastpathT) DecMapInt64IntV(v map[int64]int, canChange bool,
33616         d *Decoder) (_ map[int64]int, changed bool) {
33617         dd, esep := d.d, d.hh.hasElemSeparators()
33618         containerLen := dd.ReadMapStart()
33619         if canChange && v == nil {
33620                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
33621                 v = make(map[int64]int, xlen)
33622                 changed = true
33623         }
33624         if containerLen == 0 {
33625                 dd.ReadMapEnd()
33626                 return v, changed
33627         }
33628         d.depthIncr()
33629         var mk int64
33630         var mv int
33631         hasLen := containerLen > 0
33632         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33633                 if esep {
33634                         dd.ReadMapElemKey()
33635                 }
33636                 mk = dd.DecodeInt64()
33637                 if esep {
33638                         dd.ReadMapElemValue()
33639                 }
33640                 if dd.TryDecodeAsNil() {
33641                         if v == nil {
33642                         } else if d.h.DeleteOnNilMapValue {
33643                                 delete(v, mk)
33644                         } else {
33645                                 v[mk] = 0
33646                         }
33647                         continue
33648                 }
33649                 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
33650                 if v != nil {
33651                         v[mk] = mv
33652                 }
33653         }
33654         dd.ReadMapEnd()
33655         d.depthDecr()
33656         return v, changed
33657 }
33658
33659 func (d *Decoder) fastpathDecMapInt64Int8R(f *codecFnInfo, rv reflect.Value) {
33660         if rv.Kind() == reflect.Ptr {
33661                 vp := rv2i(rv).(*map[int64]int8)
33662                 v, changed := fastpathTV.DecMapInt64Int8V(*vp, true, d)
33663                 if changed {
33664                         *vp = v
33665                 }
33666         } else {
33667                 fastpathTV.DecMapInt64Int8V(rv2i(rv).(map[int64]int8), false, d)
33668         }
33669 }
33670 func (f fastpathT) DecMapInt64Int8X(vp *map[int64]int8, d *Decoder) {
33671         v, changed := f.DecMapInt64Int8V(*vp, true, d)
33672         if changed {
33673                 *vp = v
33674         }
33675 }
33676 func (_ fastpathT) DecMapInt64Int8V(v map[int64]int8, canChange bool,
33677         d *Decoder) (_ map[int64]int8, changed bool) {
33678         dd, esep := d.d, d.hh.hasElemSeparators()
33679         containerLen := dd.ReadMapStart()
33680         if canChange && v == nil {
33681                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
33682                 v = make(map[int64]int8, xlen)
33683                 changed = true
33684         }
33685         if containerLen == 0 {
33686                 dd.ReadMapEnd()
33687                 return v, changed
33688         }
33689         d.depthIncr()
33690         var mk int64
33691         var mv int8
33692         hasLen := containerLen > 0
33693         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33694                 if esep {
33695                         dd.ReadMapElemKey()
33696                 }
33697                 mk = dd.DecodeInt64()
33698                 if esep {
33699                         dd.ReadMapElemValue()
33700                 }
33701                 if dd.TryDecodeAsNil() {
33702                         if v == nil {
33703                         } else if d.h.DeleteOnNilMapValue {
33704                                 delete(v, mk)
33705                         } else {
33706                                 v[mk] = 0
33707                         }
33708                         continue
33709                 }
33710                 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
33711                 if v != nil {
33712                         v[mk] = mv
33713                 }
33714         }
33715         dd.ReadMapEnd()
33716         d.depthDecr()
33717         return v, changed
33718 }
33719
33720 func (d *Decoder) fastpathDecMapInt64Int16R(f *codecFnInfo, rv reflect.Value) {
33721         if rv.Kind() == reflect.Ptr {
33722                 vp := rv2i(rv).(*map[int64]int16)
33723                 v, changed := fastpathTV.DecMapInt64Int16V(*vp, true, d)
33724                 if changed {
33725                         *vp = v
33726                 }
33727         } else {
33728                 fastpathTV.DecMapInt64Int16V(rv2i(rv).(map[int64]int16), false, d)
33729         }
33730 }
33731 func (f fastpathT) DecMapInt64Int16X(vp *map[int64]int16, d *Decoder) {
33732         v, changed := f.DecMapInt64Int16V(*vp, true, d)
33733         if changed {
33734                 *vp = v
33735         }
33736 }
33737 func (_ fastpathT) DecMapInt64Int16V(v map[int64]int16, canChange bool,
33738         d *Decoder) (_ map[int64]int16, changed bool) {
33739         dd, esep := d.d, d.hh.hasElemSeparators()
33740         containerLen := dd.ReadMapStart()
33741         if canChange && v == nil {
33742                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
33743                 v = make(map[int64]int16, xlen)
33744                 changed = true
33745         }
33746         if containerLen == 0 {
33747                 dd.ReadMapEnd()
33748                 return v, changed
33749         }
33750         d.depthIncr()
33751         var mk int64
33752         var mv int16
33753         hasLen := containerLen > 0
33754         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33755                 if esep {
33756                         dd.ReadMapElemKey()
33757                 }
33758                 mk = dd.DecodeInt64()
33759                 if esep {
33760                         dd.ReadMapElemValue()
33761                 }
33762                 if dd.TryDecodeAsNil() {
33763                         if v == nil {
33764                         } else if d.h.DeleteOnNilMapValue {
33765                                 delete(v, mk)
33766                         } else {
33767                                 v[mk] = 0
33768                         }
33769                         continue
33770                 }
33771                 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
33772                 if v != nil {
33773                         v[mk] = mv
33774                 }
33775         }
33776         dd.ReadMapEnd()
33777         d.depthDecr()
33778         return v, changed
33779 }
33780
33781 func (d *Decoder) fastpathDecMapInt64Int32R(f *codecFnInfo, rv reflect.Value) {
33782         if rv.Kind() == reflect.Ptr {
33783                 vp := rv2i(rv).(*map[int64]int32)
33784                 v, changed := fastpathTV.DecMapInt64Int32V(*vp, true, d)
33785                 if changed {
33786                         *vp = v
33787                 }
33788         } else {
33789                 fastpathTV.DecMapInt64Int32V(rv2i(rv).(map[int64]int32), false, d)
33790         }
33791 }
33792 func (f fastpathT) DecMapInt64Int32X(vp *map[int64]int32, d *Decoder) {
33793         v, changed := f.DecMapInt64Int32V(*vp, true, d)
33794         if changed {
33795                 *vp = v
33796         }
33797 }
33798 func (_ fastpathT) DecMapInt64Int32V(v map[int64]int32, canChange bool,
33799         d *Decoder) (_ map[int64]int32, changed bool) {
33800         dd, esep := d.d, d.hh.hasElemSeparators()
33801         containerLen := dd.ReadMapStart()
33802         if canChange && v == nil {
33803                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
33804                 v = make(map[int64]int32, xlen)
33805                 changed = true
33806         }
33807         if containerLen == 0 {
33808                 dd.ReadMapEnd()
33809                 return v, changed
33810         }
33811         d.depthIncr()
33812         var mk int64
33813         var mv int32
33814         hasLen := containerLen > 0
33815         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33816                 if esep {
33817                         dd.ReadMapElemKey()
33818                 }
33819                 mk = dd.DecodeInt64()
33820                 if esep {
33821                         dd.ReadMapElemValue()
33822                 }
33823                 if dd.TryDecodeAsNil() {
33824                         if v == nil {
33825                         } else if d.h.DeleteOnNilMapValue {
33826                                 delete(v, mk)
33827                         } else {
33828                                 v[mk] = 0
33829                         }
33830                         continue
33831                 }
33832                 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
33833                 if v != nil {
33834                         v[mk] = mv
33835                 }
33836         }
33837         dd.ReadMapEnd()
33838         d.depthDecr()
33839         return v, changed
33840 }
33841
33842 func (d *Decoder) fastpathDecMapInt64Int64R(f *codecFnInfo, rv reflect.Value) {
33843         if rv.Kind() == reflect.Ptr {
33844                 vp := rv2i(rv).(*map[int64]int64)
33845                 v, changed := fastpathTV.DecMapInt64Int64V(*vp, true, d)
33846                 if changed {
33847                         *vp = v
33848                 }
33849         } else {
33850                 fastpathTV.DecMapInt64Int64V(rv2i(rv).(map[int64]int64), false, d)
33851         }
33852 }
33853 func (f fastpathT) DecMapInt64Int64X(vp *map[int64]int64, d *Decoder) {
33854         v, changed := f.DecMapInt64Int64V(*vp, true, d)
33855         if changed {
33856                 *vp = v
33857         }
33858 }
33859 func (_ fastpathT) DecMapInt64Int64V(v map[int64]int64, canChange bool,
33860         d *Decoder) (_ map[int64]int64, changed bool) {
33861         dd, esep := d.d, d.hh.hasElemSeparators()
33862         containerLen := dd.ReadMapStart()
33863         if canChange && v == nil {
33864                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
33865                 v = make(map[int64]int64, xlen)
33866                 changed = true
33867         }
33868         if containerLen == 0 {
33869                 dd.ReadMapEnd()
33870                 return v, changed
33871         }
33872         d.depthIncr()
33873         var mk int64
33874         var mv int64
33875         hasLen := containerLen > 0
33876         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33877                 if esep {
33878                         dd.ReadMapElemKey()
33879                 }
33880                 mk = dd.DecodeInt64()
33881                 if esep {
33882                         dd.ReadMapElemValue()
33883                 }
33884                 if dd.TryDecodeAsNil() {
33885                         if v == nil {
33886                         } else if d.h.DeleteOnNilMapValue {
33887                                 delete(v, mk)
33888                         } else {
33889                                 v[mk] = 0
33890                         }
33891                         continue
33892                 }
33893                 mv = dd.DecodeInt64()
33894                 if v != nil {
33895                         v[mk] = mv
33896                 }
33897         }
33898         dd.ReadMapEnd()
33899         d.depthDecr()
33900         return v, changed
33901 }
33902
33903 func (d *Decoder) fastpathDecMapInt64Float32R(f *codecFnInfo, rv reflect.Value) {
33904         if rv.Kind() == reflect.Ptr {
33905                 vp := rv2i(rv).(*map[int64]float32)
33906                 v, changed := fastpathTV.DecMapInt64Float32V(*vp, true, d)
33907                 if changed {
33908                         *vp = v
33909                 }
33910         } else {
33911                 fastpathTV.DecMapInt64Float32V(rv2i(rv).(map[int64]float32), false, d)
33912         }
33913 }
33914 func (f fastpathT) DecMapInt64Float32X(vp *map[int64]float32, d *Decoder) {
33915         v, changed := f.DecMapInt64Float32V(*vp, true, d)
33916         if changed {
33917                 *vp = v
33918         }
33919 }
33920 func (_ fastpathT) DecMapInt64Float32V(v map[int64]float32, canChange bool,
33921         d *Decoder) (_ map[int64]float32, changed bool) {
33922         dd, esep := d.d, d.hh.hasElemSeparators()
33923         containerLen := dd.ReadMapStart()
33924         if canChange && v == nil {
33925                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
33926                 v = make(map[int64]float32, xlen)
33927                 changed = true
33928         }
33929         if containerLen == 0 {
33930                 dd.ReadMapEnd()
33931                 return v, changed
33932         }
33933         d.depthIncr()
33934         var mk int64
33935         var mv float32
33936         hasLen := containerLen > 0
33937         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33938                 if esep {
33939                         dd.ReadMapElemKey()
33940                 }
33941                 mk = dd.DecodeInt64()
33942                 if esep {
33943                         dd.ReadMapElemValue()
33944                 }
33945                 if dd.TryDecodeAsNil() {
33946                         if v == nil {
33947                         } else if d.h.DeleteOnNilMapValue {
33948                                 delete(v, mk)
33949                         } else {
33950                                 v[mk] = 0
33951                         }
33952                         continue
33953                 }
33954                 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
33955                 if v != nil {
33956                         v[mk] = mv
33957                 }
33958         }
33959         dd.ReadMapEnd()
33960         d.depthDecr()
33961         return v, changed
33962 }
33963
33964 func (d *Decoder) fastpathDecMapInt64Float64R(f *codecFnInfo, rv reflect.Value) {
33965         if rv.Kind() == reflect.Ptr {
33966                 vp := rv2i(rv).(*map[int64]float64)
33967                 v, changed := fastpathTV.DecMapInt64Float64V(*vp, true, d)
33968                 if changed {
33969                         *vp = v
33970                 }
33971         } else {
33972                 fastpathTV.DecMapInt64Float64V(rv2i(rv).(map[int64]float64), false, d)
33973         }
33974 }
33975 func (f fastpathT) DecMapInt64Float64X(vp *map[int64]float64, d *Decoder) {
33976         v, changed := f.DecMapInt64Float64V(*vp, true, d)
33977         if changed {
33978                 *vp = v
33979         }
33980 }
33981 func (_ fastpathT) DecMapInt64Float64V(v map[int64]float64, canChange bool,
33982         d *Decoder) (_ map[int64]float64, changed bool) {
33983         dd, esep := d.d, d.hh.hasElemSeparators()
33984         containerLen := dd.ReadMapStart()
33985         if canChange && v == nil {
33986                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
33987                 v = make(map[int64]float64, xlen)
33988                 changed = true
33989         }
33990         if containerLen == 0 {
33991                 dd.ReadMapEnd()
33992                 return v, changed
33993         }
33994         d.depthIncr()
33995         var mk int64
33996         var mv float64
33997         hasLen := containerLen > 0
33998         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33999                 if esep {
34000                         dd.ReadMapElemKey()
34001                 }
34002                 mk = dd.DecodeInt64()
34003                 if esep {
34004                         dd.ReadMapElemValue()
34005                 }
34006                 if dd.TryDecodeAsNil() {
34007                         if v == nil {
34008                         } else if d.h.DeleteOnNilMapValue {
34009                                 delete(v, mk)
34010                         } else {
34011                                 v[mk] = 0
34012                         }
34013                         continue
34014                 }
34015                 mv = dd.DecodeFloat64()
34016                 if v != nil {
34017                         v[mk] = mv
34018                 }
34019         }
34020         dd.ReadMapEnd()
34021         d.depthDecr()
34022         return v, changed
34023 }
34024
34025 func (d *Decoder) fastpathDecMapInt64BoolR(f *codecFnInfo, rv reflect.Value) {
34026         if rv.Kind() == reflect.Ptr {
34027                 vp := rv2i(rv).(*map[int64]bool)
34028                 v, changed := fastpathTV.DecMapInt64BoolV(*vp, true, d)
34029                 if changed {
34030                         *vp = v
34031                 }
34032         } else {
34033                 fastpathTV.DecMapInt64BoolV(rv2i(rv).(map[int64]bool), false, d)
34034         }
34035 }
34036 func (f fastpathT) DecMapInt64BoolX(vp *map[int64]bool, d *Decoder) {
34037         v, changed := f.DecMapInt64BoolV(*vp, true, d)
34038         if changed {
34039                 *vp = v
34040         }
34041 }
34042 func (_ fastpathT) DecMapInt64BoolV(v map[int64]bool, canChange bool,
34043         d *Decoder) (_ map[int64]bool, changed bool) {
34044         dd, esep := d.d, d.hh.hasElemSeparators()
34045         containerLen := dd.ReadMapStart()
34046         if canChange && v == nil {
34047                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
34048                 v = make(map[int64]bool, xlen)
34049                 changed = true
34050         }
34051         if containerLen == 0 {
34052                 dd.ReadMapEnd()
34053                 return v, changed
34054         }
34055         d.depthIncr()
34056         var mk int64
34057         var mv bool
34058         hasLen := containerLen > 0
34059         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34060                 if esep {
34061                         dd.ReadMapElemKey()
34062                 }
34063                 mk = dd.DecodeInt64()
34064                 if esep {
34065                         dd.ReadMapElemValue()
34066                 }
34067                 if dd.TryDecodeAsNil() {
34068                         if v == nil {
34069                         } else if d.h.DeleteOnNilMapValue {
34070                                 delete(v, mk)
34071                         } else {
34072                                 v[mk] = false
34073                         }
34074                         continue
34075                 }
34076                 mv = dd.DecodeBool()
34077                 if v != nil {
34078                         v[mk] = mv
34079                 }
34080         }
34081         dd.ReadMapEnd()
34082         d.depthDecr()
34083         return v, changed
34084 }
34085
34086 func (d *Decoder) fastpathDecMapBoolIntfR(f *codecFnInfo, rv reflect.Value) {
34087         if rv.Kind() == reflect.Ptr {
34088                 vp := rv2i(rv).(*map[bool]interface{})
34089                 v, changed := fastpathTV.DecMapBoolIntfV(*vp, true, d)
34090                 if changed {
34091                         *vp = v
34092                 }
34093         } else {
34094                 fastpathTV.DecMapBoolIntfV(rv2i(rv).(map[bool]interface{}), false, d)
34095         }
34096 }
34097 func (f fastpathT) DecMapBoolIntfX(vp *map[bool]interface{}, d *Decoder) {
34098         v, changed := f.DecMapBoolIntfV(*vp, true, d)
34099         if changed {
34100                 *vp = v
34101         }
34102 }
34103 func (_ fastpathT) DecMapBoolIntfV(v map[bool]interface{}, canChange bool,
34104         d *Decoder) (_ map[bool]interface{}, changed bool) {
34105         dd, esep := d.d, d.hh.hasElemSeparators()
34106         containerLen := dd.ReadMapStart()
34107         if canChange && v == nil {
34108                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
34109                 v = make(map[bool]interface{}, xlen)
34110                 changed = true
34111         }
34112         if containerLen == 0 {
34113                 dd.ReadMapEnd()
34114                 return v, changed
34115         }
34116         d.depthIncr()
34117         mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
34118         var mk bool
34119         var mv interface{}
34120         hasLen := containerLen > 0
34121         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34122                 if esep {
34123                         dd.ReadMapElemKey()
34124                 }
34125                 mk = dd.DecodeBool()
34126                 if esep {
34127                         dd.ReadMapElemValue()
34128                 }
34129                 if dd.TryDecodeAsNil() {
34130                         if v == nil {
34131                         } else if d.h.DeleteOnNilMapValue {
34132                                 delete(v, mk)
34133                         } else {
34134                                 v[mk] = nil
34135                         }
34136                         continue
34137                 }
34138                 if mapGet {
34139                         mv = v[mk]
34140                 } else {
34141                         mv = nil
34142                 }
34143                 d.decode(&mv)
34144                 if v != nil {
34145                         v[mk] = mv
34146                 }
34147         }
34148         dd.ReadMapEnd()
34149         d.depthDecr()
34150         return v, changed
34151 }
34152
34153 func (d *Decoder) fastpathDecMapBoolStringR(f *codecFnInfo, rv reflect.Value) {
34154         if rv.Kind() == reflect.Ptr {
34155                 vp := rv2i(rv).(*map[bool]string)
34156                 v, changed := fastpathTV.DecMapBoolStringV(*vp, true, d)
34157                 if changed {
34158                         *vp = v
34159                 }
34160         } else {
34161                 fastpathTV.DecMapBoolStringV(rv2i(rv).(map[bool]string), false, d)
34162         }
34163 }
34164 func (f fastpathT) DecMapBoolStringX(vp *map[bool]string, d *Decoder) {
34165         v, changed := f.DecMapBoolStringV(*vp, true, d)
34166         if changed {
34167                 *vp = v
34168         }
34169 }
34170 func (_ fastpathT) DecMapBoolStringV(v map[bool]string, canChange bool,
34171         d *Decoder) (_ map[bool]string, changed bool) {
34172         dd, esep := d.d, d.hh.hasElemSeparators()
34173         containerLen := dd.ReadMapStart()
34174         if canChange && v == nil {
34175                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
34176                 v = make(map[bool]string, xlen)
34177                 changed = true
34178         }
34179         if containerLen == 0 {
34180                 dd.ReadMapEnd()
34181                 return v, changed
34182         }
34183         d.depthIncr()
34184         var mk bool
34185         var mv string
34186         hasLen := containerLen > 0
34187         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34188                 if esep {
34189                         dd.ReadMapElemKey()
34190                 }
34191                 mk = dd.DecodeBool()
34192                 if esep {
34193                         dd.ReadMapElemValue()
34194                 }
34195                 if dd.TryDecodeAsNil() {
34196                         if v == nil {
34197                         } else if d.h.DeleteOnNilMapValue {
34198                                 delete(v, mk)
34199                         } else {
34200                                 v[mk] = ""
34201                         }
34202                         continue
34203                 }
34204                 mv = dd.DecodeString()
34205                 if v != nil {
34206                         v[mk] = mv
34207                 }
34208         }
34209         dd.ReadMapEnd()
34210         d.depthDecr()
34211         return v, changed
34212 }
34213
34214 func (d *Decoder) fastpathDecMapBoolUintR(f *codecFnInfo, rv reflect.Value) {
34215         if rv.Kind() == reflect.Ptr {
34216                 vp := rv2i(rv).(*map[bool]uint)
34217                 v, changed := fastpathTV.DecMapBoolUintV(*vp, true, d)
34218                 if changed {
34219                         *vp = v
34220                 }
34221         } else {
34222                 fastpathTV.DecMapBoolUintV(rv2i(rv).(map[bool]uint), false, d)
34223         }
34224 }
34225 func (f fastpathT) DecMapBoolUintX(vp *map[bool]uint, d *Decoder) {
34226         v, changed := f.DecMapBoolUintV(*vp, true, d)
34227         if changed {
34228                 *vp = v
34229         }
34230 }
34231 func (_ fastpathT) DecMapBoolUintV(v map[bool]uint, canChange bool,
34232         d *Decoder) (_ map[bool]uint, changed bool) {
34233         dd, esep := d.d, d.hh.hasElemSeparators()
34234         containerLen := dd.ReadMapStart()
34235         if canChange && v == nil {
34236                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
34237                 v = make(map[bool]uint, xlen)
34238                 changed = true
34239         }
34240         if containerLen == 0 {
34241                 dd.ReadMapEnd()
34242                 return v, changed
34243         }
34244         d.depthIncr()
34245         var mk bool
34246         var mv uint
34247         hasLen := containerLen > 0
34248         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34249                 if esep {
34250                         dd.ReadMapElemKey()
34251                 }
34252                 mk = dd.DecodeBool()
34253                 if esep {
34254                         dd.ReadMapElemValue()
34255                 }
34256                 if dd.TryDecodeAsNil() {
34257                         if v == nil {
34258                         } else if d.h.DeleteOnNilMapValue {
34259                                 delete(v, mk)
34260                         } else {
34261                                 v[mk] = 0
34262                         }
34263                         continue
34264                 }
34265                 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
34266                 if v != nil {
34267                         v[mk] = mv
34268                 }
34269         }
34270         dd.ReadMapEnd()
34271         d.depthDecr()
34272         return v, changed
34273 }
34274
34275 func (d *Decoder) fastpathDecMapBoolUint8R(f *codecFnInfo, rv reflect.Value) {
34276         if rv.Kind() == reflect.Ptr {
34277                 vp := rv2i(rv).(*map[bool]uint8)
34278                 v, changed := fastpathTV.DecMapBoolUint8V(*vp, true, d)
34279                 if changed {
34280                         *vp = v
34281                 }
34282         } else {
34283                 fastpathTV.DecMapBoolUint8V(rv2i(rv).(map[bool]uint8), false, d)
34284         }
34285 }
34286 func (f fastpathT) DecMapBoolUint8X(vp *map[bool]uint8, d *Decoder) {
34287         v, changed := f.DecMapBoolUint8V(*vp, true, d)
34288         if changed {
34289                 *vp = v
34290         }
34291 }
34292 func (_ fastpathT) DecMapBoolUint8V(v map[bool]uint8, canChange bool,
34293         d *Decoder) (_ map[bool]uint8, changed bool) {
34294         dd, esep := d.d, d.hh.hasElemSeparators()
34295         containerLen := dd.ReadMapStart()
34296         if canChange && v == nil {
34297                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
34298                 v = make(map[bool]uint8, xlen)
34299                 changed = true
34300         }
34301         if containerLen == 0 {
34302                 dd.ReadMapEnd()
34303                 return v, changed
34304         }
34305         d.depthIncr()
34306         var mk bool
34307         var mv uint8
34308         hasLen := containerLen > 0
34309         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34310                 if esep {
34311                         dd.ReadMapElemKey()
34312                 }
34313                 mk = dd.DecodeBool()
34314                 if esep {
34315                         dd.ReadMapElemValue()
34316                 }
34317                 if dd.TryDecodeAsNil() {
34318                         if v == nil {
34319                         } else if d.h.DeleteOnNilMapValue {
34320                                 delete(v, mk)
34321                         } else {
34322                                 v[mk] = 0
34323                         }
34324                         continue
34325                 }
34326                 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
34327                 if v != nil {
34328                         v[mk] = mv
34329                 }
34330         }
34331         dd.ReadMapEnd()
34332         d.depthDecr()
34333         return v, changed
34334 }
34335
34336 func (d *Decoder) fastpathDecMapBoolUint16R(f *codecFnInfo, rv reflect.Value) {
34337         if rv.Kind() == reflect.Ptr {
34338                 vp := rv2i(rv).(*map[bool]uint16)
34339                 v, changed := fastpathTV.DecMapBoolUint16V(*vp, true, d)
34340                 if changed {
34341                         *vp = v
34342                 }
34343         } else {
34344                 fastpathTV.DecMapBoolUint16V(rv2i(rv).(map[bool]uint16), false, d)
34345         }
34346 }
34347 func (f fastpathT) DecMapBoolUint16X(vp *map[bool]uint16, d *Decoder) {
34348         v, changed := f.DecMapBoolUint16V(*vp, true, d)
34349         if changed {
34350                 *vp = v
34351         }
34352 }
34353 func (_ fastpathT) DecMapBoolUint16V(v map[bool]uint16, canChange bool,
34354         d *Decoder) (_ map[bool]uint16, changed bool) {
34355         dd, esep := d.d, d.hh.hasElemSeparators()
34356         containerLen := dd.ReadMapStart()
34357         if canChange && v == nil {
34358                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
34359                 v = make(map[bool]uint16, xlen)
34360                 changed = true
34361         }
34362         if containerLen == 0 {
34363                 dd.ReadMapEnd()
34364                 return v, changed
34365         }
34366         d.depthIncr()
34367         var mk bool
34368         var mv uint16
34369         hasLen := containerLen > 0
34370         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34371                 if esep {
34372                         dd.ReadMapElemKey()
34373                 }
34374                 mk = dd.DecodeBool()
34375                 if esep {
34376                         dd.ReadMapElemValue()
34377                 }
34378                 if dd.TryDecodeAsNil() {
34379                         if v == nil {
34380                         } else if d.h.DeleteOnNilMapValue {
34381                                 delete(v, mk)
34382                         } else {
34383                                 v[mk] = 0
34384                         }
34385                         continue
34386                 }
34387                 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
34388                 if v != nil {
34389                         v[mk] = mv
34390                 }
34391         }
34392         dd.ReadMapEnd()
34393         d.depthDecr()
34394         return v, changed
34395 }
34396
34397 func (d *Decoder) fastpathDecMapBoolUint32R(f *codecFnInfo, rv reflect.Value) {
34398         if rv.Kind() == reflect.Ptr {
34399                 vp := rv2i(rv).(*map[bool]uint32)
34400                 v, changed := fastpathTV.DecMapBoolUint32V(*vp, true, d)
34401                 if changed {
34402                         *vp = v
34403                 }
34404         } else {
34405                 fastpathTV.DecMapBoolUint32V(rv2i(rv).(map[bool]uint32), false, d)
34406         }
34407 }
34408 func (f fastpathT) DecMapBoolUint32X(vp *map[bool]uint32, d *Decoder) {
34409         v, changed := f.DecMapBoolUint32V(*vp, true, d)
34410         if changed {
34411                 *vp = v
34412         }
34413 }
34414 func (_ fastpathT) DecMapBoolUint32V(v map[bool]uint32, canChange bool,
34415         d *Decoder) (_ map[bool]uint32, changed bool) {
34416         dd, esep := d.d, d.hh.hasElemSeparators()
34417         containerLen := dd.ReadMapStart()
34418         if canChange && v == nil {
34419                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
34420                 v = make(map[bool]uint32, xlen)
34421                 changed = true
34422         }
34423         if containerLen == 0 {
34424                 dd.ReadMapEnd()
34425                 return v, changed
34426         }
34427         d.depthIncr()
34428         var mk bool
34429         var mv uint32
34430         hasLen := containerLen > 0
34431         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34432                 if esep {
34433                         dd.ReadMapElemKey()
34434                 }
34435                 mk = dd.DecodeBool()
34436                 if esep {
34437                         dd.ReadMapElemValue()
34438                 }
34439                 if dd.TryDecodeAsNil() {
34440                         if v == nil {
34441                         } else if d.h.DeleteOnNilMapValue {
34442                                 delete(v, mk)
34443                         } else {
34444                                 v[mk] = 0
34445                         }
34446                         continue
34447                 }
34448                 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
34449                 if v != nil {
34450                         v[mk] = mv
34451                 }
34452         }
34453         dd.ReadMapEnd()
34454         d.depthDecr()
34455         return v, changed
34456 }
34457
34458 func (d *Decoder) fastpathDecMapBoolUint64R(f *codecFnInfo, rv reflect.Value) {
34459         if rv.Kind() == reflect.Ptr {
34460                 vp := rv2i(rv).(*map[bool]uint64)
34461                 v, changed := fastpathTV.DecMapBoolUint64V(*vp, true, d)
34462                 if changed {
34463                         *vp = v
34464                 }
34465         } else {
34466                 fastpathTV.DecMapBoolUint64V(rv2i(rv).(map[bool]uint64), false, d)
34467         }
34468 }
34469 func (f fastpathT) DecMapBoolUint64X(vp *map[bool]uint64, d *Decoder) {
34470         v, changed := f.DecMapBoolUint64V(*vp, true, d)
34471         if changed {
34472                 *vp = v
34473         }
34474 }
34475 func (_ fastpathT) DecMapBoolUint64V(v map[bool]uint64, canChange bool,
34476         d *Decoder) (_ map[bool]uint64, changed bool) {
34477         dd, esep := d.d, d.hh.hasElemSeparators()
34478         containerLen := dd.ReadMapStart()
34479         if canChange && v == nil {
34480                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
34481                 v = make(map[bool]uint64, xlen)
34482                 changed = true
34483         }
34484         if containerLen == 0 {
34485                 dd.ReadMapEnd()
34486                 return v, changed
34487         }
34488         d.depthIncr()
34489         var mk bool
34490         var mv uint64
34491         hasLen := containerLen > 0
34492         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34493                 if esep {
34494                         dd.ReadMapElemKey()
34495                 }
34496                 mk = dd.DecodeBool()
34497                 if esep {
34498                         dd.ReadMapElemValue()
34499                 }
34500                 if dd.TryDecodeAsNil() {
34501                         if v == nil {
34502                         } else if d.h.DeleteOnNilMapValue {
34503                                 delete(v, mk)
34504                         } else {
34505                                 v[mk] = 0
34506                         }
34507                         continue
34508                 }
34509                 mv = dd.DecodeUint64()
34510                 if v != nil {
34511                         v[mk] = mv
34512                 }
34513         }
34514         dd.ReadMapEnd()
34515         d.depthDecr()
34516         return v, changed
34517 }
34518
34519 func (d *Decoder) fastpathDecMapBoolUintptrR(f *codecFnInfo, rv reflect.Value) {
34520         if rv.Kind() == reflect.Ptr {
34521                 vp := rv2i(rv).(*map[bool]uintptr)
34522                 v, changed := fastpathTV.DecMapBoolUintptrV(*vp, true, d)
34523                 if changed {
34524                         *vp = v
34525                 }
34526         } else {
34527                 fastpathTV.DecMapBoolUintptrV(rv2i(rv).(map[bool]uintptr), false, d)
34528         }
34529 }
34530 func (f fastpathT) DecMapBoolUintptrX(vp *map[bool]uintptr, d *Decoder) {
34531         v, changed := f.DecMapBoolUintptrV(*vp, true, d)
34532         if changed {
34533                 *vp = v
34534         }
34535 }
34536 func (_ fastpathT) DecMapBoolUintptrV(v map[bool]uintptr, canChange bool,
34537         d *Decoder) (_ map[bool]uintptr, changed bool) {
34538         dd, esep := d.d, d.hh.hasElemSeparators()
34539         containerLen := dd.ReadMapStart()
34540         if canChange && v == nil {
34541                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
34542                 v = make(map[bool]uintptr, xlen)
34543                 changed = true
34544         }
34545         if containerLen == 0 {
34546                 dd.ReadMapEnd()
34547                 return v, changed
34548         }
34549         d.depthIncr()
34550         var mk bool
34551         var mv uintptr
34552         hasLen := containerLen > 0
34553         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34554                 if esep {
34555                         dd.ReadMapElemKey()
34556                 }
34557                 mk = dd.DecodeBool()
34558                 if esep {
34559                         dd.ReadMapElemValue()
34560                 }
34561                 if dd.TryDecodeAsNil() {
34562                         if v == nil {
34563                         } else if d.h.DeleteOnNilMapValue {
34564                                 delete(v, mk)
34565                         } else {
34566                                 v[mk] = 0
34567                         }
34568                         continue
34569                 }
34570                 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
34571                 if v != nil {
34572                         v[mk] = mv
34573                 }
34574         }
34575         dd.ReadMapEnd()
34576         d.depthDecr()
34577         return v, changed
34578 }
34579
34580 func (d *Decoder) fastpathDecMapBoolIntR(f *codecFnInfo, rv reflect.Value) {
34581         if rv.Kind() == reflect.Ptr {
34582                 vp := rv2i(rv).(*map[bool]int)
34583                 v, changed := fastpathTV.DecMapBoolIntV(*vp, true, d)
34584                 if changed {
34585                         *vp = v
34586                 }
34587         } else {
34588                 fastpathTV.DecMapBoolIntV(rv2i(rv).(map[bool]int), false, d)
34589         }
34590 }
34591 func (f fastpathT) DecMapBoolIntX(vp *map[bool]int, d *Decoder) {
34592         v, changed := f.DecMapBoolIntV(*vp, true, d)
34593         if changed {
34594                 *vp = v
34595         }
34596 }
34597 func (_ fastpathT) DecMapBoolIntV(v map[bool]int, canChange bool,
34598         d *Decoder) (_ map[bool]int, changed bool) {
34599         dd, esep := d.d, d.hh.hasElemSeparators()
34600         containerLen := dd.ReadMapStart()
34601         if canChange && v == nil {
34602                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
34603                 v = make(map[bool]int, xlen)
34604                 changed = true
34605         }
34606         if containerLen == 0 {
34607                 dd.ReadMapEnd()
34608                 return v, changed
34609         }
34610         d.depthIncr()
34611         var mk bool
34612         var mv int
34613         hasLen := containerLen > 0
34614         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34615                 if esep {
34616                         dd.ReadMapElemKey()
34617                 }
34618                 mk = dd.DecodeBool()
34619                 if esep {
34620                         dd.ReadMapElemValue()
34621                 }
34622                 if dd.TryDecodeAsNil() {
34623                         if v == nil {
34624                         } else if d.h.DeleteOnNilMapValue {
34625                                 delete(v, mk)
34626                         } else {
34627                                 v[mk] = 0
34628                         }
34629                         continue
34630                 }
34631                 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
34632                 if v != nil {
34633                         v[mk] = mv
34634                 }
34635         }
34636         dd.ReadMapEnd()
34637         d.depthDecr()
34638         return v, changed
34639 }
34640
34641 func (d *Decoder) fastpathDecMapBoolInt8R(f *codecFnInfo, rv reflect.Value) {
34642         if rv.Kind() == reflect.Ptr {
34643                 vp := rv2i(rv).(*map[bool]int8)
34644                 v, changed := fastpathTV.DecMapBoolInt8V(*vp, true, d)
34645                 if changed {
34646                         *vp = v
34647                 }
34648         } else {
34649                 fastpathTV.DecMapBoolInt8V(rv2i(rv).(map[bool]int8), false, d)
34650         }
34651 }
34652 func (f fastpathT) DecMapBoolInt8X(vp *map[bool]int8, d *Decoder) {
34653         v, changed := f.DecMapBoolInt8V(*vp, true, d)
34654         if changed {
34655                 *vp = v
34656         }
34657 }
34658 func (_ fastpathT) DecMapBoolInt8V(v map[bool]int8, canChange bool,
34659         d *Decoder) (_ map[bool]int8, changed bool) {
34660         dd, esep := d.d, d.hh.hasElemSeparators()
34661         containerLen := dd.ReadMapStart()
34662         if canChange && v == nil {
34663                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
34664                 v = make(map[bool]int8, xlen)
34665                 changed = true
34666         }
34667         if containerLen == 0 {
34668                 dd.ReadMapEnd()
34669                 return v, changed
34670         }
34671         d.depthIncr()
34672         var mk bool
34673         var mv int8
34674         hasLen := containerLen > 0
34675         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34676                 if esep {
34677                         dd.ReadMapElemKey()
34678                 }
34679                 mk = dd.DecodeBool()
34680                 if esep {
34681                         dd.ReadMapElemValue()
34682                 }
34683                 if dd.TryDecodeAsNil() {
34684                         if v == nil {
34685                         } else if d.h.DeleteOnNilMapValue {
34686                                 delete(v, mk)
34687                         } else {
34688                                 v[mk] = 0
34689                         }
34690                         continue
34691                 }
34692                 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
34693                 if v != nil {
34694                         v[mk] = mv
34695                 }
34696         }
34697         dd.ReadMapEnd()
34698         d.depthDecr()
34699         return v, changed
34700 }
34701
34702 func (d *Decoder) fastpathDecMapBoolInt16R(f *codecFnInfo, rv reflect.Value) {
34703         if rv.Kind() == reflect.Ptr {
34704                 vp := rv2i(rv).(*map[bool]int16)
34705                 v, changed := fastpathTV.DecMapBoolInt16V(*vp, true, d)
34706                 if changed {
34707                         *vp = v
34708                 }
34709         } else {
34710                 fastpathTV.DecMapBoolInt16V(rv2i(rv).(map[bool]int16), false, d)
34711         }
34712 }
34713 func (f fastpathT) DecMapBoolInt16X(vp *map[bool]int16, d *Decoder) {
34714         v, changed := f.DecMapBoolInt16V(*vp, true, d)
34715         if changed {
34716                 *vp = v
34717         }
34718 }
34719 func (_ fastpathT) DecMapBoolInt16V(v map[bool]int16, canChange bool,
34720         d *Decoder) (_ map[bool]int16, changed bool) {
34721         dd, esep := d.d, d.hh.hasElemSeparators()
34722         containerLen := dd.ReadMapStart()
34723         if canChange && v == nil {
34724                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
34725                 v = make(map[bool]int16, xlen)
34726                 changed = true
34727         }
34728         if containerLen == 0 {
34729                 dd.ReadMapEnd()
34730                 return v, changed
34731         }
34732         d.depthIncr()
34733         var mk bool
34734         var mv int16
34735         hasLen := containerLen > 0
34736         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34737                 if esep {
34738                         dd.ReadMapElemKey()
34739                 }
34740                 mk = dd.DecodeBool()
34741                 if esep {
34742                         dd.ReadMapElemValue()
34743                 }
34744                 if dd.TryDecodeAsNil() {
34745                         if v == nil {
34746                         } else if d.h.DeleteOnNilMapValue {
34747                                 delete(v, mk)
34748                         } else {
34749                                 v[mk] = 0
34750                         }
34751                         continue
34752                 }
34753                 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
34754                 if v != nil {
34755                         v[mk] = mv
34756                 }
34757         }
34758         dd.ReadMapEnd()
34759         d.depthDecr()
34760         return v, changed
34761 }
34762
34763 func (d *Decoder) fastpathDecMapBoolInt32R(f *codecFnInfo, rv reflect.Value) {
34764         if rv.Kind() == reflect.Ptr {
34765                 vp := rv2i(rv).(*map[bool]int32)
34766                 v, changed := fastpathTV.DecMapBoolInt32V(*vp, true, d)
34767                 if changed {
34768                         *vp = v
34769                 }
34770         } else {
34771                 fastpathTV.DecMapBoolInt32V(rv2i(rv).(map[bool]int32), false, d)
34772         }
34773 }
34774 func (f fastpathT) DecMapBoolInt32X(vp *map[bool]int32, d *Decoder) {
34775         v, changed := f.DecMapBoolInt32V(*vp, true, d)
34776         if changed {
34777                 *vp = v
34778         }
34779 }
34780 func (_ fastpathT) DecMapBoolInt32V(v map[bool]int32, canChange bool,
34781         d *Decoder) (_ map[bool]int32, changed bool) {
34782         dd, esep := d.d, d.hh.hasElemSeparators()
34783         containerLen := dd.ReadMapStart()
34784         if canChange && v == nil {
34785                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
34786                 v = make(map[bool]int32, xlen)
34787                 changed = true
34788         }
34789         if containerLen == 0 {
34790                 dd.ReadMapEnd()
34791                 return v, changed
34792         }
34793         d.depthIncr()
34794         var mk bool
34795         var mv int32
34796         hasLen := containerLen > 0
34797         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34798                 if esep {
34799                         dd.ReadMapElemKey()
34800                 }
34801                 mk = dd.DecodeBool()
34802                 if esep {
34803                         dd.ReadMapElemValue()
34804                 }
34805                 if dd.TryDecodeAsNil() {
34806                         if v == nil {
34807                         } else if d.h.DeleteOnNilMapValue {
34808                                 delete(v, mk)
34809                         } else {
34810                                 v[mk] = 0
34811                         }
34812                         continue
34813                 }
34814                 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
34815                 if v != nil {
34816                         v[mk] = mv
34817                 }
34818         }
34819         dd.ReadMapEnd()
34820         d.depthDecr()
34821         return v, changed
34822 }
34823
34824 func (d *Decoder) fastpathDecMapBoolInt64R(f *codecFnInfo, rv reflect.Value) {
34825         if rv.Kind() == reflect.Ptr {
34826                 vp := rv2i(rv).(*map[bool]int64)
34827                 v, changed := fastpathTV.DecMapBoolInt64V(*vp, true, d)
34828                 if changed {
34829                         *vp = v
34830                 }
34831         } else {
34832                 fastpathTV.DecMapBoolInt64V(rv2i(rv).(map[bool]int64), false, d)
34833         }
34834 }
34835 func (f fastpathT) DecMapBoolInt64X(vp *map[bool]int64, d *Decoder) {
34836         v, changed := f.DecMapBoolInt64V(*vp, true, d)
34837         if changed {
34838                 *vp = v
34839         }
34840 }
34841 func (_ fastpathT) DecMapBoolInt64V(v map[bool]int64, canChange bool,
34842         d *Decoder) (_ map[bool]int64, changed bool) {
34843         dd, esep := d.d, d.hh.hasElemSeparators()
34844         containerLen := dd.ReadMapStart()
34845         if canChange && v == nil {
34846                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
34847                 v = make(map[bool]int64, xlen)
34848                 changed = true
34849         }
34850         if containerLen == 0 {
34851                 dd.ReadMapEnd()
34852                 return v, changed
34853         }
34854         d.depthIncr()
34855         var mk bool
34856         var mv int64
34857         hasLen := containerLen > 0
34858         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34859                 if esep {
34860                         dd.ReadMapElemKey()
34861                 }
34862                 mk = dd.DecodeBool()
34863                 if esep {
34864                         dd.ReadMapElemValue()
34865                 }
34866                 if dd.TryDecodeAsNil() {
34867                         if v == nil {
34868                         } else if d.h.DeleteOnNilMapValue {
34869                                 delete(v, mk)
34870                         } else {
34871                                 v[mk] = 0
34872                         }
34873                         continue
34874                 }
34875                 mv = dd.DecodeInt64()
34876                 if v != nil {
34877                         v[mk] = mv
34878                 }
34879         }
34880         dd.ReadMapEnd()
34881         d.depthDecr()
34882         return v, changed
34883 }
34884
34885 func (d *Decoder) fastpathDecMapBoolFloat32R(f *codecFnInfo, rv reflect.Value) {
34886         if rv.Kind() == reflect.Ptr {
34887                 vp := rv2i(rv).(*map[bool]float32)
34888                 v, changed := fastpathTV.DecMapBoolFloat32V(*vp, true, d)
34889                 if changed {
34890                         *vp = v
34891                 }
34892         } else {
34893                 fastpathTV.DecMapBoolFloat32V(rv2i(rv).(map[bool]float32), false, d)
34894         }
34895 }
34896 func (f fastpathT) DecMapBoolFloat32X(vp *map[bool]float32, d *Decoder) {
34897         v, changed := f.DecMapBoolFloat32V(*vp, true, d)
34898         if changed {
34899                 *vp = v
34900         }
34901 }
34902 func (_ fastpathT) DecMapBoolFloat32V(v map[bool]float32, canChange bool,
34903         d *Decoder) (_ map[bool]float32, changed bool) {
34904         dd, esep := d.d, d.hh.hasElemSeparators()
34905         containerLen := dd.ReadMapStart()
34906         if canChange && v == nil {
34907                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
34908                 v = make(map[bool]float32, xlen)
34909                 changed = true
34910         }
34911         if containerLen == 0 {
34912                 dd.ReadMapEnd()
34913                 return v, changed
34914         }
34915         d.depthIncr()
34916         var mk bool
34917         var mv float32
34918         hasLen := containerLen > 0
34919         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34920                 if esep {
34921                         dd.ReadMapElemKey()
34922                 }
34923                 mk = dd.DecodeBool()
34924                 if esep {
34925                         dd.ReadMapElemValue()
34926                 }
34927                 if dd.TryDecodeAsNil() {
34928                         if v == nil {
34929                         } else if d.h.DeleteOnNilMapValue {
34930                                 delete(v, mk)
34931                         } else {
34932                                 v[mk] = 0
34933                         }
34934                         continue
34935                 }
34936                 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
34937                 if v != nil {
34938                         v[mk] = mv
34939                 }
34940         }
34941         dd.ReadMapEnd()
34942         d.depthDecr()
34943         return v, changed
34944 }
34945
34946 func (d *Decoder) fastpathDecMapBoolFloat64R(f *codecFnInfo, rv reflect.Value) {
34947         if rv.Kind() == reflect.Ptr {
34948                 vp := rv2i(rv).(*map[bool]float64)
34949                 v, changed := fastpathTV.DecMapBoolFloat64V(*vp, true, d)
34950                 if changed {
34951                         *vp = v
34952                 }
34953         } else {
34954                 fastpathTV.DecMapBoolFloat64V(rv2i(rv).(map[bool]float64), false, d)
34955         }
34956 }
34957 func (f fastpathT) DecMapBoolFloat64X(vp *map[bool]float64, d *Decoder) {
34958         v, changed := f.DecMapBoolFloat64V(*vp, true, d)
34959         if changed {
34960                 *vp = v
34961         }
34962 }
34963 func (_ fastpathT) DecMapBoolFloat64V(v map[bool]float64, canChange bool,
34964         d *Decoder) (_ map[bool]float64, changed bool) {
34965         dd, esep := d.d, d.hh.hasElemSeparators()
34966         containerLen := dd.ReadMapStart()
34967         if canChange && v == nil {
34968                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
34969                 v = make(map[bool]float64, xlen)
34970                 changed = true
34971         }
34972         if containerLen == 0 {
34973                 dd.ReadMapEnd()
34974                 return v, changed
34975         }
34976         d.depthIncr()
34977         var mk bool
34978         var mv float64
34979         hasLen := containerLen > 0
34980         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34981                 if esep {
34982                         dd.ReadMapElemKey()
34983                 }
34984                 mk = dd.DecodeBool()
34985                 if esep {
34986                         dd.ReadMapElemValue()
34987                 }
34988                 if dd.TryDecodeAsNil() {
34989                         if v == nil {
34990                         } else if d.h.DeleteOnNilMapValue {
34991                                 delete(v, mk)
34992                         } else {
34993                                 v[mk] = 0
34994                         }
34995                         continue
34996                 }
34997                 mv = dd.DecodeFloat64()
34998                 if v != nil {
34999                         v[mk] = mv
35000                 }
35001         }
35002         dd.ReadMapEnd()
35003         d.depthDecr()
35004         return v, changed
35005 }
35006
35007 func (d *Decoder) fastpathDecMapBoolBoolR(f *codecFnInfo, rv reflect.Value) {
35008         if rv.Kind() == reflect.Ptr {
35009                 vp := rv2i(rv).(*map[bool]bool)
35010                 v, changed := fastpathTV.DecMapBoolBoolV(*vp, true, d)
35011                 if changed {
35012                         *vp = v
35013                 }
35014         } else {
35015                 fastpathTV.DecMapBoolBoolV(rv2i(rv).(map[bool]bool), false, d)
35016         }
35017 }
35018 func (f fastpathT) DecMapBoolBoolX(vp *map[bool]bool, d *Decoder) {
35019         v, changed := f.DecMapBoolBoolV(*vp, true, d)
35020         if changed {
35021                 *vp = v
35022         }
35023 }
35024 func (_ fastpathT) DecMapBoolBoolV(v map[bool]bool, canChange bool,
35025         d *Decoder) (_ map[bool]bool, changed bool) {
35026         dd, esep := d.d, d.hh.hasElemSeparators()
35027         containerLen := dd.ReadMapStart()
35028         if canChange && v == nil {
35029                 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
35030                 v = make(map[bool]bool, xlen)
35031                 changed = true
35032         }
35033         if containerLen == 0 {
35034                 dd.ReadMapEnd()
35035                 return v, changed
35036         }
35037         d.depthIncr()
35038         var mk bool
35039         var mv bool
35040         hasLen := containerLen > 0
35041         for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
35042                 if esep {
35043                         dd.ReadMapElemKey()
35044                 }
35045                 mk = dd.DecodeBool()
35046                 if esep {
35047                         dd.ReadMapElemValue()
35048                 }
35049                 if dd.TryDecodeAsNil() {
35050                         if v == nil {
35051                         } else if d.h.DeleteOnNilMapValue {
35052                                 delete(v, mk)
35053                         } else {
35054                                 v[mk] = false
35055                         }
35056                         continue
35057                 }
35058                 mv = dd.DecodeBool()
35059                 if v != nil {
35060                         v[mk] = mv
35061                 }
35062         }
35063         dd.ReadMapEnd()
35064         d.depthDecr()
35065         return v, changed
35066 }